pax_global_header00006660000000000000000000000064146372210220014511gustar00rootroot0000000000000052 comment=f9262283ef24e78ecced7d08fbde8c2381ec7f94 ocaml-stdcompat-20~git20240529/000077500000000000000000000000001463722102200161155ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/.gitattributes000066400000000000000000000001671463722102200210140ustar00rootroot00000000000000ci/*.sh -text .github/scripts/*.sh text eol=lf /configure text eol=lf /Makefile.in text eol=lf /install-sh text eol=lf ocaml-stdcompat-20~git20240529/.gitignore000066400000000000000000000010571463722102200201100ustar00rootroot00000000000000_build/ *.install .merlin *~ *.[ao] *.cm[aiotx] *.cmti *.cmx[as] /Makefile /autom4te.cache /doc/ /tests.bytecode /tests.native /META /stdcompat.ml_byte /stdcompat.ml_native /.depend /stdcompat_*.ml /stdcompat_*.mli !/stdcompat__native.mli /interface_generator/interface_dumper /interface_generator/interface_generator /interface_generator/.depend /stdcompat.ml /stdcompat.mli /config.guess /config.log /config.status /config.sub /config.h *.so /stdcompat__stubs.c /stdcompat__native.ml_native /stdcompat__native.ml_byte /stdcompat.h /stdcompat__domain.mli.in ocaml-stdcompat-20~git20240529/AUTHORS000066400000000000000000000000541463722102200171640ustar00rootroot00000000000000Thierry Martinez ocaml-stdcompat-20~git20240529/CHANGES.md000066400000000000000000000214321463722102200175110ustar00rootroot00000000000000# Version 20 - Compatibility with OCaml 5.1 and 5.2 - Fix `Illegal seek` exception in `In_channel.input_all` - #23, #24, #25: Fix `dune` build on Windows. (reported by Kay-Uwe Kirstein) - Fix `Makefile`-based build system on Windows. (reported by Noteeeeeee, https://github.com/thierry-martinez/pyml/issues/88 ) - Upstream `opam-repository-mingw` patch for DLL extensions (suggested by Kay-Uwe Kirstein) # Version 19, 2022-07-08 - Compatibility with OCaml 5.0 - Add `String.{hash, seeded_hash}` - Restore compatibility with OCaml 3.07, and fix order execution for `Set` and `Map.{iter, fold, filter_map}` on OCaml 3.07 - Updated port to `dune` (Marek Kubica, https://github.com/thierry-martinez/stdcompat/pull/16, https://github.com/thierry-martinez/stdcompat/pull/19 with contribution from Kate, https://github.com/thierry-martinez/stdcompat/pull/21 ) - Add support for `flambda2` (Guillaume Bury, https://github.com/thierry-martinez/stdcompat/pull/14 ) - Prevent replacing `/dev/null/` by a regular file when `./configure` is run as root (reported by Marc Chevalier, https://github.com/ocaml/ocaml/issues/11302 ) # Version 18, 2022-02-09 - Support for OCaml 4.14 with - Lot of new functions in `Seq` - `Uchar.utf_decode` and co - `In_channel` and `Out_channel` modules - `Sys.{development_version, ocaml_release}` - Add `Stdlib.{acosh,asinh,atanh}` missing from 4.13 and `Stdlib.__FUNCTION__` missing from 4.12 - Add module `Unit` missing from 4.08 - Add module `Random`, with new functions introduced from 4.13 - `Filename.chop_suffix` checks that suffixes match and fails otherwise (behavior introduced in 4.14) - `Buffer.add_channel` adds data read from the channel even if `End_of_file` has been reached (behavior introduced in 4.03) - Add dependency for generating `.cmt` files (reported by Sabyrzhan Tasbolatov) # Version 17, 2021-09-28 - Fix: missing prototype for `caml_alloc_initialized_string` in `stdcompat.h` - Fix: linking with `stdcompat__stubs` in bytecode # Version 16, 2021-07-09 - Support for OCaml 4.13.0 with - `Seq.{concat, concat_map}` - `{Int{32, 64}, Nativeint}.{min, max}` - `Array.{fold_left_map, find_opt, find_map, split, combine}` - `Bytes.{fold_left, fold_right, for_all, exists, starts_with, ends_with, split_on_char}` - `String.{fold_left, fold_right, for_all, exists, starts_with, ends_with, get_{u,}int8, get_{{u,}int16,int32,int64}{_ne,_be,_le}}` - `Format.{pp_print_either, pp_print_bytes, print_bytes}` - Add module `Atomic` - Fix `{Array,Bytes,List,More,String}Labels` modules - Fix: equality between `Stdcompat.Lexing.lexbuf` and `Lexing.lexbuf` types even for OCaml <4.02 (the equality was not preserved since the type of lex_buffer was syntactically different, string instead of bytes) # Version 15, 2021-02-17 - Support for OCaml 4.12.0 with - `Sys.{mkdir, rmdir}` - `{Set,Map}.to_rev_seq` - `Either` module - `List.{partition_map, compare, equal}` - `Hashtbl.rebuild` - `Format.pp_print_seq` - VERSION file was missing in distributed archive # Version 14, 2020-05-10 - Support for OCaml 4.11.0 with - Array.{for_all2, exists2} - Lexing.{set_position, set_filename} - List.{filteri, fold_left_map} - Printexc.{default_uncaught_exception_handler, Slot.name} - Seq.{cons, append, unfold} - {Set,Map}.filter_map - Printf.{ibprintf, ikbprintf} - More efficient implementation of Set functions - Support for version mismatch between ocamlc and ocamlfind packages # Version 13, 2020-02-22 - Add: stdcompat.h, provides prototype for caml_alloc_initialized_string for OCaml <4.06.0 (already defined in a C library linked with stdcompat.{cma,cmxa}). - Fix: module Format was not exported - Fix: remove reference to suppressed module Sort - Fix: reference to the native plugin (.cmxs) in META # Version 12, 2020-02-08 - Support for OCaml 4.10.0 - Support for Windows - Add Bytes.unsafe_blit_string, Filename.quote_command, List.concat_map, List.find_map, Sys.Immediate64 - Equality Lexing.lexbuf = Stdcompat.Lexing.lexbuf is available even for OCaml <4.02.0 (before the introduction of bytes) # Version 11, 2019-09-30 - caml_alloc_initialized_string is now available for OCaml 4.05.0 - Add Printexc.to_string_default and Printexc.use_printers # Version 10, 2019-06-26 - New C stub with definition of caml_alloc_initialized_string for OCaml <4.05.0 - Fix: Printexc is no longer opaque - Generate -bin-annot .cmt files for OCaml >=4.00.0 # Version 9, 2019-03-12 - [compatibility break] Pervasives.protect has been moved to Fun.protect since its introduction in OCaml trunk - Support for OCaml 4.08.0: additions to modules Float, Format (mostly unimplemented), Fun, List (filter_map), Sys (max_floatarray_length) - ocamlfind has been added as depopt since its presence changes the behvior of configure script - Printexc has been added: substitution functions are mostly unimplemented, except for get_raw_backtrace (which returns ()) and raise_with_backtrace (which calls raise) - Fix: equality between aliases of Seq.t # Version 8, 2018-12-10 - Fix: module Fun was not exported - Fix: value Stdlib.protect was not exported - Fix: equality between aliases of Stdlib.result and of Seq.t - Fix: Stdlib.result redefined before 4.03 (instead of 4.06) # Version 7, 2018-11-28 - OCaml 4.08.0 additions: Bool, Fun, Array.t, List.t, Bytes and Buffer operations on u?int(8|16|32|64), operations on Float, Filename.chop_suffix_opt - Modules Format and Printf added to the set of redefined modules # Version 6, 2018-09-10 - Support for OCaml 4.08.0 - Support VPATH build, i.e. when configure is executed in a build directory distinct from the source directory - Lexing.new_line - Bigarray: only available from 4.02.0. From 4.02.0 and before 4.07.0, --no-alias-deps is used to allow the alias to appear in Stdcompat without requiring the library to be linked. Bigarray library should be linked if it is effectively used. - Fix implementations with --disable-magic - Fix license conflict: The project was intended to be under BSD license since the beginning, and a LICENSE file was provided accordingly. However, automake generated a COPYING file with the GPLv3 by default. The COPYING file now contains the BSD license, and the LICENSE file is removed. (reported by Török Edwin, https://github.com/thierry-martinez/stdcompat/issues/5) - Fix auto-generated interfaces for Hashtbl.MakeSeeded - Exceptions are reexported again. They were missing in auto-generated interfaces. - min_binding_opt and max_binding_opt are not redefined if OCaml >=4.05. - Array.of_seq is redefined in OCaml 4.07.0 to circumvent a bug in the implementation of the standard library. See: - https://caml.inria.fr/mantis/view.php?id=7820 - https://github.com/ocaml/ocaml/pull/1897 # Version 5, 2018-07-11 - Interfaces are auto-generated. - stdcompat is now free from any required dependency. There are still optional dependencies with respect to the packages result, seq and uchar: stdcompat takes care of providing types compatible with these packages if they are installed. - Preprocessing is performed by "./configure" script (generated by autoconf). cppo and the C preprocessor are no longer used. - Makefile is generated by automake. ocamlfind is no longer required for installation. - Split implementation into one module for each standard library module (suggested by Yotam Barnoy: https://github.com/thierry-martinez/stdcompat/issues/4) - All modules are now exported as sub-modules of Stdlib module (as in OCaml 4.07) -- Bigarray is not exported to allow programs not to be compiled with this module, this may change in the future. (suggested by Yotam Barnoy: https://github.com/thierry-martinez/stdcompat/issues/4) - Compatibility with uchar package # Version 4, 2018-05-30 - Fix link problems with hypot, copy_sign, ldexp and classify_float # Version 3, 2018-04-25 - Missing List.of_seq/List.to_seq - Remove spurious Float.seeded_hash_param (suggested by Hezekiah M. Carty: https://github.com/thierry-martinez/stdcompat/pull/2) - Compatibility with seq and result packages (suggested by Hezekiah M. Carty: https://github.com/thierry-martinez/stdcompat/issues/1) - Magic implementations of {Set,Map,Hashtbl,Queue,Stack}.to_seq*, Hashtbl.filter_map_inplace, Hashtbl.stats, Stack.fold, Set.find*, Set.map. Pure implementations are available by building with "make USE_MAGIC=false" - jbuild script (Hezekiah M. Carty) # Version 2, 2018-04-19 - Redefinitions for Pervasives are now in Stdcompat.Pervasives (they were previously defined at the root of Stdcompat), and the module Stdcompat.Pervasives is included in Stdcompat, so that opening Stdcompat makes the redefinitions visible in the scope. - Float module (OCaml 4.07.0) - Seq module and of_seq/to_seq/... # Version 1, 2017-11-14 - Initial release ocaml-stdcompat-20~git20240529/COPYING000066400000000000000000000024071463722102200171530ustar00rootroot00000000000000Copyright (c) 2017-2021, Thierry Martinez. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ocaml-stdcompat-20~git20240529/Dockerfile000066400000000000000000000033311463722102200201070ustar00rootroot00000000000000FROM ubuntu ARG UID=1000 RUN apt-get update && apt-get install --yes autoconf automake unzip aspcud rsync \ git mercurial darcs wget build-essential sudo vim curl RUN useradd -m -s /bin/bash ci --uid=${UID} RUN echo ci ALL=\(ALL\) NOPASSWD:ALL >/etc/sudoers USER ci RUN wget -O ~/opam https://github.com/ocaml/opam/releases/download/2.1.2/opam-2.1.2-x86_64-linux RUN chmod +x ~/opam RUN sudo mv ~/opam /usr/local/bin/opam RUN opam init --disable-sandboxing --auto-setup --dot-profile=/home/ci/.bash_env SHELL ["/bin/bash", "-c"] ENV BASH_ENV /home/ci/.bash_env RUN opam update && opam switch create 3.07 RUN opam update && opam switch create 3.08.4 RUN opam update && opam switch create 3.09.3 RUN opam update && opam switch create 3.10.2 RUN opam update && opam switch create 3.11.2 RUN opam update && opam switch create 3.12.1 RUN opam update && opam switch create 4.00.1 RUN opam update && opam switch create 4.01.0 RUN opam update && opam switch create 4.02.3 RUN opam update && opam switch create 4.03.0 RUN opam update && opam switch create 4.04.2 RUN opam update && opam switch create 4.05.0 RUN opam update && opam switch create 4.06.1 RUN opam update && opam switch create 4.07.0 RUN opam update && opam switch create 4.07.1 RUN opam update && opam switch create 4.08.1 RUN opam update && opam switch create 4.09.1 RUN opam update && opam switch create 4.10.2 RUN opam update && opam switch create 4.11.2 RUN opam update && opam switch create 4.12.1 RUN opam update && opam switch create 4.13.1 RUN opam update && opam switch create 4.14.0 RUN opam update && opam switch create 5.0.0~alpha0 RUN opam update && \ opam switch create 5.0.0+trunk \ --repositories=default,beta=git+https://github.com/ocaml/ocaml-beta-repository.git ocaml-stdcompat-20~git20240529/INSTALL000066400000000000000000000366141463722102200171600ustar00rootroot00000000000000Installation Instructions ************************* Copyright (C) 1994-1996, 1999-2002, 2004-2016 Free Software Foundation, Inc. Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without warranty of any kind. Basic Installation ================== Briefly, the shell command './configure && make && make install' should configure, build, and install this package. The following more-detailed instructions are generic; see the 'README' file for instructions specific to this package. Some packages provide this 'INSTALL' file but do not implement all of the features documented below. The lack of an optional feature in a given package is not necessarily a bug. More recommendations for GNU packages can be found in *note Makefile Conventions: (standards)Makefile Conventions. The 'configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a 'Makefile' in each directory of the package. It may also create one or more '.h' files containing system-dependent definitions. Finally, it creates a shell script 'config.status' that you can run in the future to recreate the current configuration, and a file 'config.log' containing compiler output (useful mainly for debugging 'configure'). It can also use an optional file (typically called 'config.cache' and enabled with '--cache-file=config.cache' or simply '-C') that saves the results of its tests to speed up reconfiguring. Caching is disabled by default to prevent problems with accidental use of stale cache files. If you need to do unusual things to compile the package, please try to figure out how 'configure' could check whether to do them, and mail diffs or instructions to the address given in the 'README' so they can be considered for the next release. If you are using the cache, and at some point 'config.cache' contains results you don't want to keep, you may remove or edit it. The file 'configure.ac' (or 'configure.in') is used to create 'configure' by a program called 'autoconf'. You need 'configure.ac' if you want to change it or regenerate 'configure' using a newer version of 'autoconf'. The simplest way to compile this package is: 1. 'cd' to the directory containing the package's source code and type './configure' to configure the package for your system. Running 'configure' might take a while. While running, it prints some messages telling which features it is checking for. 2. Type 'make' to compile the package. 3. Optionally, type 'make check' to run any self-tests that come with the package, generally using the just-built uninstalled binaries. 4. Type 'make install' to install the programs and any data files and documentation. When installing into a prefix owned by root, it is recommended that the package be configured and built as a regular user, and only the 'make install' phase executed with root privileges. 5. Optionally, type 'make installcheck' to repeat any self-tests, but this time using the binaries in their final installed location. This target does not install anything. Running this target as a regular user, particularly if the prior 'make install' required root privileges, verifies that the installation completed correctly. 6. You can remove the program binaries and object files from the source code directory by typing 'make clean'. To also remove the files that 'configure' created (so you can compile the package for a different kind of computer), type 'make distclean'. There is also a 'make maintainer-clean' target, but that is intended mainly for the package's developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution. 7. Often, you can also type 'make uninstall' to remove the installed files again. In practice, not all packages have tested that uninstallation works correctly, even though it is required by the GNU Coding Standards. 8. Some packages, particularly those that use Automake, provide 'make distcheck', which can by used by developers to test that all other targets like 'make install' and 'make uninstall' work correctly. This target is generally not run by end users. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the 'configure' script does not know about. Run './configure --help' for details on some of the pertinent environment variables. You can give 'configure' initial values for configuration parameters by setting variables in the command line or in the environment. Here is an example: ./configure CC=c99 CFLAGS=-g LIBS=-lposix *Note Defining Variables::, for more details. Compiling For Multiple Architectures ==================================== You can compile the package for more than one kind of computer at the same time, by placing the object files for each architecture in their own directory. To do this, you can use GNU 'make'. 'cd' to the directory where you want the object files and executables to go and run the 'configure' script. 'configure' automatically checks for the source code in the directory that 'configure' is in and in '..'. This is known as a "VPATH" build. With a non-GNU 'make', it is safer to compile the package for one architecture at a time in the source code directory. After you have installed the package for one architecture, use 'make distclean' before reconfiguring for another architecture. On MacOS X 10.5 and later systems, you can create libraries and executables that work on multiple system types--known as "fat" or "universal" binaries--by specifying multiple '-arch' options to the compiler but only a single '-arch' option to the preprocessor. Like this: ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CPP="gcc -E" CXXCPP="g++ -E" This is not guaranteed to produce working output in all cases, you may have to build one architecture at a time and combine the results using the 'lipo' tool if you have problems. Installation Names ================== By default, 'make install' installs the package's commands under '/usr/local/bin', include files under '/usr/local/include', etc. You can specify an installation prefix other than '/usr/local' by giving 'configure' the option '--prefix=PREFIX', where PREFIX must be an absolute file name. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you pass the option '--exec-prefix=PREFIX' to 'configure', the package uses PREFIX as the prefix for installing programs and libraries. Documentation and other data files still use the regular prefix. In addition, if you use an unusual directory layout you can give options like '--bindir=DIR' to specify different values for particular kinds of files. Run 'configure --help' for a list of the directories you can set and what kinds of files go in them. In general, the default for these options is expressed in terms of '${prefix}', so that specifying just '--prefix' will affect all of the other directory specifications that were not explicitly provided. The most portable way to affect installation locations is to pass the correct locations to 'configure'; however, many packages provide one or both of the following shortcuts of passing variable assignments to the 'make install' command line to change installation locations without having to reconfigure or recompile. The first method involves providing an override variable for each affected directory. For example, 'make install prefix=/alternate/directory' will choose an alternate location for all directory configuration variables that were expressed in terms of '${prefix}'. Any directories that were specified during 'configure', but not in terms of '${prefix}', must each be overridden at install time for the entire installation to be relocated. The approach of makefile variable overrides for each directory variable is required by the GNU Coding Standards, and ideally causes no recompilation. However, some platforms have known limitations with the semantics of shared libraries that end up requiring recompilation when using this method, particularly noticeable in packages that use GNU Libtool. The second method involves providing the 'DESTDIR' variable. For example, 'make install DESTDIR=/alternate/directory' will prepend '/alternate/directory' before all installation names. The approach of 'DESTDIR' overrides is not required by the GNU Coding Standards, and does not work on platforms that have drive letters. On the other hand, it does better at avoiding recompilation issues, and works well even when some directory options were not specified in terms of '${prefix}' at 'configure' time. Optional Features ================= If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving 'configure' the option '--program-prefix=PREFIX' or '--program-suffix=SUFFIX'. Some packages pay attention to '--enable-FEATURE' options to 'configure', where FEATURE indicates an optional part of the package. They may also pay attention to '--with-PACKAGE' options, where PACKAGE is something like 'gnu-as' or 'x' (for the X Window System). The 'README' should mention any '--enable-' and '--with-' options that the package recognizes. For packages that use the X Window System, 'configure' can usually find the X include and library files automatically, but if it doesn't, you can use the 'configure' options '--x-includes=DIR' and '--x-libraries=DIR' to specify their locations. Some packages offer the ability to configure how verbose the execution of 'make' will be. For these packages, running './configure --enable-silent-rules' sets the default to minimal output, which can be overridden with 'make V=1'; while running './configure --disable-silent-rules' sets the default to verbose, which can be overridden with 'make V=0'. Particular systems ================== On HP-UX, the default C compiler is not ANSI C compatible. If GNU CC is not installed, it is recommended to use the following options in order to use an ANSI C compiler: ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" and if that doesn't work, install pre-built binaries of GCC for HP-UX. HP-UX 'make' updates targets which have the same time stamps as their prerequisites, which makes it generally unusable when shipped generated files such as 'configure' are involved. Use GNU 'make' instead. On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot parse its '' header file. The option '-nodtk' can be used as a workaround. If GNU CC is not installed, it is therefore recommended to try ./configure CC="cc" and if that doesn't work, try ./configure CC="cc -nodtk" On Solaris, don't put '/usr/ucb' early in your 'PATH'. This directory contains several dysfunctional programs; working variants of these programs are available in '/usr/bin'. So, if you need '/usr/ucb' in your 'PATH', put it _after_ '/usr/bin'. On Haiku, software installed for all users goes in '/boot/common', not '/usr/local'. It is recommended to use the following options: ./configure --prefix=/boot/common Specifying the System Type ========================== There may be some features 'configure' cannot figure out automatically, but needs to determine by the type of machine the package will run on. Usually, assuming the package is built to be run on the _same_ architectures, 'configure' can figure that out, but if it prints a message saying it cannot guess the machine type, give it the '--build=TYPE' option. TYPE can either be a short name for the system type, such as 'sun4', or a canonical name which has the form: CPU-COMPANY-SYSTEM where SYSTEM can have one of these forms: OS KERNEL-OS See the file 'config.sub' for the possible values of each field. If 'config.sub' isn't included in this package, then this package doesn't need to know the machine type. If you are _building_ compiler tools for cross-compiling, you should use the option '--target=TYPE' to select the type of system they will produce code for. If you want to _use_ a cross compiler, that generates code for a platform different from the build platform, you should specify the "host" platform (i.e., that on which the generated programs will eventually be run) with '--host=TYPE'. Sharing Defaults ================ If you want to set default values for 'configure' scripts to share, you can create a site shell script called 'config.site' that gives default values for variables like 'CC', 'cache_file', and 'prefix'. 'configure' looks for 'PREFIX/share/config.site' if it exists, then 'PREFIX/etc/config.site' if it exists. Or, you can set the 'CONFIG_SITE' environment variable to the location of the site script. A warning: not all 'configure' scripts look for a site script. Defining Variables ================== Variables not defined in a site shell script can be set in the environment passed to 'configure'. However, some packages may run configure again during the build, and the customized values of these variables may be lost. In order to avoid this problem, you should set them in the 'configure' command line, using 'VAR=value'. For example: ./configure CC=/usr/local2/bin/gcc causes the specified 'gcc' to be used as the C compiler (unless it is overridden in the site shell script). Unfortunately, this technique does not work for 'CONFIG_SHELL' due to an Autoconf limitation. Until the limitation is lifted, you can use this workaround: CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash 'configure' Invocation ====================== 'configure' recognizes the following options to control how it operates. '--help' '-h' Print a summary of all of the options to 'configure', and exit. '--help=short' '--help=recursive' Print a summary of the options unique to this package's 'configure', and exit. The 'short' variant lists options used only in the top level, while the 'recursive' variant lists options also present in any nested packages. '--version' '-V' Print the version of Autoconf used to generate the 'configure' script, and exit. '--cache-file=FILE' Enable the cache: use and save the results of the tests in FILE, traditionally 'config.cache'. FILE defaults to '/dev/null' to disable caching. '--config-cache' '-C' Alias for '--cache-file=config.cache'. '--quiet' '--silent' '-q' Do not print messages saying which checks are being made. To suppress all normal output, redirect it to '/dev/null' (any error messages will still be shown). '--srcdir=DIR' Look for the package's source code in directory DIR. Usually 'configure' can determine that directory automatically. '--prefix=DIR' Use DIR as the installation prefix. *note Installation Names:: for more details, including other options available for fine-tuning the installation locations. '--no-create' '-n' Run the configure checks, but stop before creating any output files. 'configure' also accepts some other, not widely useful, options. Run 'configure --help' for more details. ocaml-stdcompat-20~git20240529/Jenkinsfile000066400000000000000000000076761463722102200203210ustar00rootroot00000000000000properties([ [ $class: 'ThrottleJobProperty', categories: ['category'], limitOneJobWithMatchingParams: false, maxConcurrentPerNode: 4, maxConcurrentTotal: 0, paramsToUseForLimit: '', throttleEnabled: true, throttleOption: 'category' ], ]) pipeline { agent none stages { stage('Prepare') { agent { label 'linux' } steps { sh 'docker build -t stdcompat . --build-arg UID=$(id -u)' } } stage('Bootstrap') { agent { label 'linux' } steps { sh 'docker run --rm --volume $PWD:/workspace stdcompat bash -c \'cd /workspace && make -f Makefile.bootstrap\'' stash name: 'bootstrap' } } stage('Configure') { agent { label 'linux' } steps { unstash 'bootstrap' sh 'docker run --rm --volume $PWD:/workspace stdcompat bash -c \'cd /workspace && mkdir build && cd build && ../configure\'' stash name: 'configure' } } stage('Build') { agent { label 'linux' } steps { unstash 'configure' sh 'docker run --rm --volume $PWD:/workspace stdcompat bash -c \'cd /workspace/build && make\'' } } stage('Tests') { agent { label 'linux' } steps { script { def switches = sh ( script: 'docker run --rm stdcompat opam switch -s', returnStdout: true ).split('\n') def branches = [:] for (i in switches) { def switch_name = i branches["OCaml " + switch_name + " on Linux"] = { node('linux') { sh "rm -rf build" unstash 'bootstrap' sh "docker run --rm --volume \$PWD:/workspace stdcompat sh -c 'cd /workspace && unset BASH_ENV && opam config exec --switch $switch_name -- sh -c '\\''mkdir build && cd build && ../configure && make && make test && ../configure --disable-magic && make && make test'\\'" } } } def versions = ["4.03.0", "4.04.2", "4.05.0", "4.06.1", "4.07.1", "4.08.1", "4.09.1", "4.10.2", "4.11.2", "4.12.1", "4.13.1", "4.14.0"] for (i in versions) { def version = i branches["OCaml " + version + " on Windows"] = { node('windows') { checkout scm bat """ call "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\vcvars64.bat" set PATH=C:\\tools\\cygwin\\bin;%PATH% bash -c "ci/cygwin-compile-ocaml.sh \\"$version\\"" if not errorlevel 0 exit /b set PATH=C:\\ocaml\\$version\\bin;%PATH% set FLEXDIR=C:\\ocaml\\$version\\lib bash -c "eval \$(~/ocaml-4.09.0/tools/msvs-promote-path) && make -f Makefile.bootstrap && ./configure && make && make test" """ } } } throttle(['category']) { parallel branches } } } } stage('Deploy') { agent { label 'linux' } steps { unstash 'configure' sh 'docker run --rm --volume $PWD:/workspace stdcompat bash -c \'cd /workspace/build && make dist\'' archiveArtifacts artifacts: 'build/*.tar.gz', fingerprint: true } } } } ocaml-stdcompat-20~git20240529/META.in000066400000000000000000000004241463722102200171730ustar00rootroot00000000000000description = "Stdcompat: compatibility module for OCaml standard library" requires = "@SEQ_PKG@ @RESULT_PKG@ @UCHAR_PKG@" version = "@VERSION@" archive(byte) = "stdcompat.cma" archive(native) = "stdcompat.cmxa" plugin(byte) = "stdcompat.cma" plugin(native) = "@SHARED_LIBS@" ocaml-stdcompat-20~git20240529/Makefile.am000066400000000000000000000162131463722102200201540ustar00rootroot00000000000000mypkgdir=$(pkglibdir) EXTRA_DIST= stdcompat.opam dune stdcompat.ml stdcompat__native.ml_byte \ stdcompat__native.ml_native stdcompat_tests.ml stdcompat__native.mli \ stdcompat__pervasives.mli stdcompat__arg.mli stdcompat__lazy.mli \ stdcompat__char.mli stdcompat__uchar.mli stdcompat__sys.mli stdcompat__buffer.mli \ stdcompat__string.mli stdcompat__stringLabels.mli stdcompat__bytes.mli \ stdcompat__bytesLabels.mli stdcompat__list.mli \ stdcompat__listLabels.mli \ stdcompat__stack.mli \ stdcompat__hashtbl.mli stdcompat__set.mli \ stdcompat__map.mli stdcompat__weak.mli \ stdcompat__digest.mli stdcompat__nativeint.mli \ stdcompat__int.mli \ stdcompat__int64.mli stdcompat__int32.mli stdcompat__filename.mli \ stdcompat__array.mli stdcompat__arrayLabels.mli \ stdcompat__float.mli stdcompat__queue.mli stdcompat__ephemeron.mli \ stdcompat__moreLabels.mli stdcompat__lexing.mli \ stdcompat__option.mli stdcompat__printexc.mli \ stdcompat__random.mli \ stdcompat__result.mli stdcompat__bool.mli stdcompat__domain.mli \ stdcompat__fun.mli stdcompat__format.mli stdcompat__printf.mli stdcompat__stdlib.mli \ stdcompat__seq.mli stdcompat__printexc.mli \ stdcompat__either.mli stdcompat__atomic.mli \ stdcompat__unit.mli \ stdcompat__in_channel.mli stdcompat__out_channel.mli Makefile.bootstrap VERSION \ dune-project dune MODULES = stdcompat__init.ml stdcompat__root.ml \ stdcompat__either_s.ml stdcompat__either.ml \ stdcompat__seq_s.ml \ stdcompat__seq.ml stdcompat__tools.ml \ stdcompat__pervasives_s.ml stdcompat__arg_s.ml stdcompat__lazy_s.ml \ stdcompat__char_s.ml stdcompat__uchar_s.ml stdcompat__uchar.ml \ stdcompat__buffer_s.ml \ stdcompat__string_s.ml stdcompat__stringLabels_s.ml stdcompat__bytes_s.ml \ stdcompat__bytesLabels_s.ml \ stdcompat__list_s.ml \ stdcompat__listLabels_s.ml \ stdcompat__stack_s.ml \ stdcompat__list.ml \ stdcompat__hashtbl_ext.ml stdcompat__hashtbl_s.ml stdcompat__set_s.ml \ stdcompat__map_s.ml stdcompat__weak_s.ml stdcompat__sys_s.ml \ stdcompat__digest_s.ml stdcompat__nativeint_s.ml \ stdcompat__int_s.ml \ stdcompat__int64_s.ml stdcompat__int32_s.ml stdcompat__filename_s.ml \ stdcompat__array_s.ml stdcompat__arrayLabels_s.ml \ stdcompat__float_s.ml stdcompat__queue_s.ml \ stdcompat__hashtbl.ml \ stdcompat__ephemeron_s.ml \ stdcompat__moreLabels_s.ml stdcompat__lexing_s.ml \ stdcompat__pervasives.ml \ stdcompat__option_s.ml stdcompat__result_s.ml stdcompat__bool_s.ml \ stdcompat__fun_s.ml stdcompat__printf_s.ml stdcompat__domain_s.ml \ stdcompat__domain.ml \ stdcompat__printexc_s.ml stdcompat__format_s.ml stdcompat__atomic_s.ml \ stdcompat__in_channel_s.ml stdcompat__out_channel_s.ml \ stdcompat__random_s.ml \ stdcompat__unit_s.ml \ stdcompat__stdlib_s.ml \ stdcompat__arg.ml stdcompat__lazy.ml \ stdcompat__char.ml \ stdcompat__option.ml \ stdcompat__buffer.ml stdcompat__sys.ml \ stdcompat__bytes.ml stdcompat__bytesLabels.ml \ stdcompat__string.ml stdcompat__stringLabels.ml \ stdcompat__filename.ml \ stdcompat__listLabels.ml \ stdcompat__stack.ml stdcompat__set.ml \ stdcompat__map.ml stdcompat__weak.ml \ stdcompat__random.ml \ stdcompat__digest.ml stdcompat__nativeint.ml \ stdcompat__int.ml stdcompat__int64.ml stdcompat__int32.ml \ stdcompat__array.ml stdcompat__arrayLabels.ml \ stdcompat__float.ml stdcompat__queue.ml stdcompat__ephemeron.ml \ stdcompat__moreLabels.ml stdcompat__lexing.ml \ stdcompat__printexc.ml stdcompat__result.ml stdcompat__bool.ml \ stdcompat__fun.ml stdcompat__format.ml stdcompat__printf.ml \ stdcompat__atomic.ml \ stdcompat__in_channel.ml stdcompat__out_channel.ml \ stdcompat__unit.ml \ stdcompat__stdlib.ml stdcompat.ml # From https://github.com/fdopen/opam-repository-mingw/commit/3b4c52e17cfae96cfbf5120b60b8c2bbf5aad252 # We prefer DLLEXT to conform with EXEEXT and OBJEXT DLLEXT := $(shell ocamlc -config | awk -F '[\t\r ]+' '/^ext_dll:/ {print $$2}') # Fix install on Windows (https://github.com/thierry-martinez/pyml/issues/88) LIBEXT := $(shell ocamlc -config | awk -F '[\t\r ]+' '/^ext_lib:/ {print $$2}') MODULES_native = stdcompat__native.ml $(MODULES) mypkg_SCRIPTS = META $(MODULES_native) $(MODULES_native:.ml=.cmi) \ libstdcompat__stubs$(LIBEXT) stdcompat.h if OCAML_SUPPORTS_BYTECODE mypkg_SCRIPTS += stdcompat.cma BEST_SUFFIX := .cmo endif if OCAML_SUPPORTS_NATIVE mypkg_SCRIPTS += stdcompat.cmxa stdcompat$(LIBEXT) $(MODULES_native:.ml=.cmx) BEST_SUFFIX := .cmx endif if OCAML_SUPPORTS_SHARED mypkg_SCRIPTS += stdcompat.cmxs endif PACKAGES = $(RESULT_PKG) $(SEQ_PKG) $(UCHAR_PKG) OCAMLFLAGS = $(PACKAGES:%=-package %) OCAMLCFLAGS = $(OCAMLFLAGS) -nolabels -I @srcdir@ OCAMLLDFLAGS = $(OCAMLFLAGS) OCAMLLIBFLAGS = -cclib "-L. -lstdcompat__stubs" if OCAML_SUPPORTS_BIN_ANNOT OCAMLFLAGS += -bin-annot mypkg_SCRIPTS += $(MODULES_native:.ml=.cmt) endif if OCAML_SUPPORTS_NO_ALIAS_DEPS OCAMLFLAGS += -no-alias-deps endif if OCAML_SUPPORTS_ALERT OCAMLCFLAGS += -alert -deprecated endif STDCOMPAT_TESTS_EXE = stdcompat_tests$(EXEEXT) SUFFIXES = .ml .mli .cmi .cmo .cmx .cmxa .cmxs .cmt .DEFAULT_GOAL = all .mli.cmi : $(OCAMLBEST) -c $(OCAMLCFLAGS) $< -o $@ .ml.cmo : $(OCAMLC) -c $(OCAMLCFLAGS) $< -o $@ .ml.cmx : $(OCAMLOPT) -c $(OCAMLCFLAGS) $< -o $@ $(BEST_SUFFIX).cmt : ; stdcompat__stubs.$(OBJEXT) : stdcompat__stubs.c $(OCAMLC) -c $< libstdcompat__stubs$(LIBEXT) : stdcompat__stubs.$(OBJEXT) $(OCAMLMKLIB) -o stdcompat__stubs $< dllstdcompat__stubs$(DLLEXT) : libstdcompat__stubs$(LIBEXT) stdcompat.cma : $(MODULES_native:.ml=.cmo) libstdcompat__stubs$(LIBEXT) $(OCAMLC) $(OCAMLLDFLAGS) -a $(MODULES_native:.ml=.cmo) \ $(OCAMLLIBFLAGS) -dllib -lstdcompat__stubs -o $@ stdcompat.cmxa : $(MODULES_native:.ml=.cmx) libstdcompat__stubs$(LIBEXT) $(OCAMLOPT) $(OCAMLLDFLAGS) -a $(MODULES_native:.ml=.cmx) $(OCAMLLIBFLAGS) -o $@ stdcompat$(LIBEXT) : stdcompat.cmxa stdcompat.cmxs : $(MODULES_native:.ml=.cmx) libstdcompat__stubs$(LIBEXT) $(OCAMLOPT) $(OCAMLLDFLAGS) -shared $(MODULES_native:.ml=.cmx) $(OCAMLLIBFLAGS) -o $@ # Fake dependency to rebuild stdcompat__native.cmi on compiler change stdcompat__native.cmi : config.status stdcompat__native.cmo : stdcompat__native.ml_byte stdcompat__native.cmi $(OCAMLC) $(OCAMLCFLAGS) -c -impl stdcompat__native.ml_byte stdcompat__native.cmx : stdcompat__native.ml_native stdcompat__native.cmi $(OCAMLOPT) $(OCAMLCFLAGS) -c -impl stdcompat__native.ml_native .PHONY : depend depend : .depend .depend : $(MODULES) $(MODULES_native:.ml=.mli) stdcompat.ml stdcompat__native.ml_byte cp stdcompat__native.ml_byte stdcompat__native.ml $(OCAMLDEP) $^ >$@ || rm -f .depend .PHONY : test test : $(STDCOMPAT_TESTS_EXE) ./$(STDCOMPAT_TESTS_EXE) $(STDCOMPAT_TESTS_EXE): stdcompat.$(CMAX) stdcompat_tests.ml $(OCAMLBEST) stdcompat.$(CMAX) stdcompat_tests.ml -o $@ @INCLUDE_DEPEND@ CLEANFILES = *.cmi *.cmo *.cmx *.cmt *.cmti *.$(OBJEXT) *$(LIBEXT) stdcompat.cma \ stdcompat.cmxa stdcompat__native.ml dllstdcompat__stubs$(DLLEXT) \ stdcompat.cmxs $(STDCOMPAT_TESTS_EXE) $(bin_SCRIPTS) .depend install-exec-hook : $(MKDIR_P) $(DESTDIR)$(libdir)/stublibs $(INSTALL_PROGRAM) dllstdcompat__stubs$(DLLEXT) $(DESTDIR)$(libdir)/stublibs echo stdcompat >$(DESTDIR)$(libdir)/stublibs/dllstdcompat__stubs$(DLLEXT).owner ocaml-stdcompat-20~git20240529/Makefile.bootstrap000066400000000000000000000003701463722102200215710ustar00rootroot00000000000000.PHONY : all all : config.h.in aclocal.m4 Makefile.in configure config.h.in : configure.ac autoheader aclocal.m4 : configure.ac aclocal Makefile.in : aclocal.m4 Makefile.am automake --add-missing configure : aclocal.m4 configure.ac autoconfocaml-stdcompat-20~git20240529/Makefile.config.in000066400000000000000000000002731463722102200214300ustar00rootroot00000000000000OCAMLFIND := @OCAMLFIND@ OCAMLOPT := @OCAMLOPT@ OCAMLC := @OCAMLC@ OCAMLDOC := @OCAMLDOC@ OCAMLBEST := @OCAMLBEST@ RESULT_PKG := @RESULT_PKG@ SEQ_PKG := @SEQ_PKG@ UCHAR_PKG := @UCHAR_PKG@ocaml-stdcompat-20~git20240529/Makefile.in000066400000000000000000002407641463722102200201770ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.5 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2021 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : @OCAML_SUPPORTS_BYTECODE_TRUE@am__append_1 = stdcompat.cma @OCAML_SUPPORTS_NATIVE_TRUE@am__append_2 = stdcompat.cmxa stdcompat$(LIBEXT) $(MODULES_native:.ml=.cmx) @OCAML_SUPPORTS_SHARED_TRUE@am__append_3 = stdcompat.cmxs @OCAML_SUPPORTS_BIN_ANNOT_TRUE@am__append_4 = -bin-annot @OCAML_SUPPORTS_BIN_ANNOT_TRUE@am__append_5 = $(MODULES_native:.ml=.cmt) @OCAML_SUPPORTS_NO_ALIAS_DEPS_TRUE@am__append_6 = -no-alias-deps @OCAML_SUPPORTS_ALERT_TRUE@am__append_7 = -alert -deprecated subdir = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(am__DIST_COMMON) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_HEADER = config.h CONFIG_CLEAN_FILES = META stdcompat__hashtbl_ext.mli \ stdcompat__hashtbl_ext.ml stdcompat__init.mli \ stdcompat__init.ml stdcompat__root.mli stdcompat__root.ml \ stdcompat__tools.mli stdcompat__tools.ml \ stdcompat__native.ml_byte stdcompat__native.ml_native \ stdcompat_tests.ml stdcompat.h stdcompat__stubs.c \ stdcompat__pervasives_s.mli stdcompat__arg_s.mli \ stdcompat__array_s.mli stdcompat__arrayLabels_s.mli \ stdcompat__atomic_s.mli stdcompat__bool_s.mli \ stdcompat__buffer_s.mli stdcompat__bytes_s.mli \ stdcompat__bytesLabels_s.mli stdcompat__char_s.mli \ stdcompat__digest_s.mli stdcompat__domain_s.mli \ stdcompat__either_s.mli stdcompat__ephemeron_s.mli \ stdcompat__filename_s.mli stdcompat__float_s.mli \ stdcompat__format_s.mli stdcompat__fun_s.mli \ stdcompat__hashtbl_s.mli stdcompat__in_channel_s.mli \ stdcompat__int_s.mli stdcompat__int32_s.mli \ stdcompat__int64_s.mli stdcompat__lazy_s.mli \ stdcompat__lexing_s.mli stdcompat__list_s.mli \ stdcompat__listLabels_s.mli stdcompat__map_s.mli \ stdcompat__moreLabels_s.mli stdcompat__nativeint_s.mli \ stdcompat__option_s.mli stdcompat__out_channel_s.mli \ stdcompat__printexc_s.mli stdcompat__printf_s.mli \ stdcompat__queue_s.mli stdcompat__random_s.mli \ stdcompat__result_s.mli stdcompat__seq_s.mli \ stdcompat__set_s.mli stdcompat__stack_s.mli \ stdcompat__string_s.mli stdcompat__stringLabels_s.mli \ stdcompat__sys_s.mli stdcompat__uchar_s.mli \ stdcompat__weak_s.mli stdcompat__unit_s.mli \ stdcompat__stdlib_s.mli stdcompat__pervasives_s.ml \ stdcompat__arg_s.ml stdcompat__array_s.ml \ stdcompat__arrayLabels_s.ml stdcompat__atomic_s.ml \ stdcompat__bool_s.ml stdcompat__buffer_s.ml \ stdcompat__bytes_s.ml stdcompat__bytesLabels_s.ml \ stdcompat__char_s.ml stdcompat__digest_s.ml \ stdcompat__domain_s.ml stdcompat__either_s.ml \ stdcompat__ephemeron_s.ml stdcompat__filename_s.ml \ stdcompat__float_s.ml stdcompat__format_s.ml \ stdcompat__fun_s.ml stdcompat__hashtbl_s.ml \ stdcompat__int_s.ml stdcompat__int32_s.ml \ stdcompat__int64_s.ml stdcompat__lazy_s.ml \ stdcompat__lexing_s.ml stdcompat__list_s.ml \ stdcompat__listLabels_s.ml stdcompat__map_s.ml \ stdcompat__moreLabels_s.ml stdcompat__nativeint_s.ml \ stdcompat__option_s.ml stdcompat__printexc_s.ml \ stdcompat__printf_s.ml stdcompat__queue_s.ml \ stdcompat__random_s.ml stdcompat__result_s.ml \ stdcompat__seq_s.ml stdcompat__set_s.ml stdcompat__stack_s.ml \ stdcompat__stdlib_s.ml stdcompat__string_s.ml \ stdcompat__stringLabels_s.ml stdcompat__sys_s.ml \ stdcompat__uchar_s.ml stdcompat__weak_s.ml \ stdcompat__in_channel_s.ml stdcompat__out_channel_s.ml \ stdcompat__unit_s.ml stdcompat__pervasives.ml \ stdcompat__arg.ml stdcompat__array.ml \ stdcompat__arrayLabels.ml stdcompat__atomic.ml \ stdcompat__bool.ml stdcompat__buffer.ml stdcompat__bytes.ml \ stdcompat__bytesLabels.ml stdcompat__char.ml \ stdcompat__digest.ml stdcompat__domain.ml stdcompat__either.ml \ stdcompat__ephemeron.ml stdcompat__filename.ml \ stdcompat__float.ml stdcompat__format.ml stdcompat__fun.ml \ stdcompat__hashtbl.ml stdcompat__int.ml stdcompat__int32.ml \ stdcompat__int64.ml stdcompat__lazy.ml stdcompat__lexing.ml \ stdcompat__list.ml stdcompat__listLabels.ml stdcompat__map.ml \ stdcompat__moreLabels.ml stdcompat__nativeint.ml \ stdcompat__option.ml stdcompat__printexc.ml \ stdcompat__printf.ml stdcompat__queue.ml stdcompat__random.ml \ stdcompat__result.ml stdcompat__seq.ml stdcompat__set.ml \ stdcompat__stack.ml stdcompat__stdlib.ml stdcompat__string.ml \ stdcompat__stringLabels.ml stdcompat__sys.ml \ stdcompat__uchar.ml stdcompat__weak.ml \ stdcompat__in_channel.ml stdcompat__out_channel.ml \ stdcompat__unit.ml stdcompat__pervasives.mli \ stdcompat__arg.mli stdcompat__array.mli \ stdcompat__arrayLabels.mli stdcompat__atomic.mli \ stdcompat__bool.mli stdcompat__buffer.mli stdcompat__bytes.mli \ stdcompat__bytesLabels.mli stdcompat__char.mli \ stdcompat__digest.mli stdcompat__domain.mli \ stdcompat__either.mli stdcompat__ephemeron.mli \ stdcompat__filename.mli stdcompat__float.mli \ stdcompat__format.mli stdcompat__fun.mli \ stdcompat__hashtbl.mli stdcompat__int.mli stdcompat__int32.mli \ stdcompat__int64.mli stdcompat__lazy.mli stdcompat__lexing.mli \ stdcompat__list.mli stdcompat__listLabels.mli \ stdcompat__map.mli stdcompat__moreLabels.mli \ stdcompat__nativeint.mli stdcompat__option.mli \ stdcompat__printexc.mli stdcompat__printf.mli \ stdcompat__queue.mli stdcompat__random.mli \ stdcompat__result.mli stdcompat__seq.mli stdcompat__set.mli \ stdcompat__stack.mli stdcompat__stdlib.mli \ stdcompat__string.mli stdcompat__stringLabels.mli \ stdcompat__sys.mli stdcompat__uchar.mli stdcompat__weak.mli \ stdcompat__in_channel.mli stdcompat__out_channel.mli \ stdcompat__unit.mli stdcompat.mli stdcompat.ml CONFIG_CLEAN_VPATH_FILES = am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ test -z "$$files" \ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && rm -f $$files; }; \ } am__installdirs = "$(DESTDIR)$(mypkgdir)" SCRIPTS = $(mypkg_SCRIPTS) AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_@AM_V@) am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_@AM_V@) am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) am__v_at_0 = @ am__v_at_1 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) \ config.h.in # Read a list of newline-separated strings from the standard input, # and print each of them once, without duplicates. Input order is # *not* preserved. am__uniquify_input = $(AWK) '\ BEGIN { nonempty = 0; } \ { items[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in items) print i; }; } \ ' # Make sure the list of sources is unique. This is necessary because, # e.g., the same source file might be shared among _SOURCES variables # for different programs/libraries. am__define_uniq_tagged_files = \ list='$(am__tagged_files)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | $(am__uniquify_input)` AM_RECURSIVE_TARGETS = cscope am__DIST_COMMON = $(srcdir)/META.in $(srcdir)/Makefile.in \ $(srcdir)/config.h.in $(srcdir)/stdcompat.h.in \ $(srcdir)/stdcompat.ml.in $(srcdir)/stdcompat.mli.in \ $(srcdir)/stdcompat__arg.ml.in $(srcdir)/stdcompat__arg.mli.in \ $(srcdir)/stdcompat__arg_s.mli.in \ $(srcdir)/stdcompat__array.ml.in \ $(srcdir)/stdcompat__array.mli.in \ $(srcdir)/stdcompat__arrayLabels.ml.in \ $(srcdir)/stdcompat__arrayLabels.mli.in \ $(srcdir)/stdcompat__arrayLabels_s.mli.in \ $(srcdir)/stdcompat__array_s.mli.in \ $(srcdir)/stdcompat__atomic.ml.in \ $(srcdir)/stdcompat__atomic.mli.in \ $(srcdir)/stdcompat__atomic_s.mli.in \ $(srcdir)/stdcompat__bool.ml.in \ $(srcdir)/stdcompat__bool.mli.in \ $(srcdir)/stdcompat__bool_s.mli.in \ $(srcdir)/stdcompat__buffer.ml.in \ $(srcdir)/stdcompat__buffer.mli.in \ $(srcdir)/stdcompat__buffer_s.mli.in \ $(srcdir)/stdcompat__bytes.ml.in \ $(srcdir)/stdcompat__bytes.mli.in \ $(srcdir)/stdcompat__bytesLabels.ml.in \ $(srcdir)/stdcompat__bytesLabels.mli.in \ $(srcdir)/stdcompat__bytesLabels_s.mli.in \ $(srcdir)/stdcompat__bytes_s.mli.in \ $(srcdir)/stdcompat__char.ml.in \ $(srcdir)/stdcompat__char.mli.in \ $(srcdir)/stdcompat__char_s.mli.in \ $(srcdir)/stdcompat__digest.ml.in \ $(srcdir)/stdcompat__digest.mli.in \ $(srcdir)/stdcompat__digest_s.mli.in \ $(srcdir)/stdcompat__domain.ml.in \ $(srcdir)/stdcompat__domain.mli.in \ $(srcdir)/stdcompat__domain_s.mli.in \ $(srcdir)/stdcompat__either.ml.in \ $(srcdir)/stdcompat__either.mli.in \ $(srcdir)/stdcompat__either_s.mli.in \ $(srcdir)/stdcompat__ephemeron.ml.in \ $(srcdir)/stdcompat__ephemeron.mli.in \ $(srcdir)/stdcompat__ephemeron_s.mli.in \ $(srcdir)/stdcompat__filename.ml.in \ $(srcdir)/stdcompat__filename.mli.in \ $(srcdir)/stdcompat__filename_s.mli.in \ $(srcdir)/stdcompat__float.ml.in \ $(srcdir)/stdcompat__float.mli.in \ $(srcdir)/stdcompat__float_s.mli.in \ $(srcdir)/stdcompat__format.ml.in \ $(srcdir)/stdcompat__format.mli.in \ $(srcdir)/stdcompat__format_s.mli.in \ $(srcdir)/stdcompat__fun.ml.in $(srcdir)/stdcompat__fun.mli.in \ $(srcdir)/stdcompat__fun_s.mli.in \ $(srcdir)/stdcompat__hashtbl.ml.in \ $(srcdir)/stdcompat__hashtbl.mli.in \ $(srcdir)/stdcompat__hashtbl_ext.ml.in \ $(srcdir)/stdcompat__hashtbl_ext.mli.in \ $(srcdir)/stdcompat__hashtbl_s.mli.in \ $(srcdir)/stdcompat__in_channel.ml.in \ $(srcdir)/stdcompat__in_channel.mli.in \ $(srcdir)/stdcompat__in_channel_s.mli.in \ $(srcdir)/stdcompat__init.mli.in \ $(srcdir)/stdcompat__int.ml.in $(srcdir)/stdcompat__int.mli.in \ $(srcdir)/stdcompat__int32.ml.in \ $(srcdir)/stdcompat__int32.mli.in \ $(srcdir)/stdcompat__int32_s.mli.in \ $(srcdir)/stdcompat__int64.ml.in \ $(srcdir)/stdcompat__int64.mli.in \ $(srcdir)/stdcompat__int64_s.mli.in \ $(srcdir)/stdcompat__int_s.mli.in \ $(srcdir)/stdcompat__lazy.ml.in \ $(srcdir)/stdcompat__lazy.mli.in \ $(srcdir)/stdcompat__lazy_s.mli.in \ $(srcdir)/stdcompat__lexing.ml.in \ $(srcdir)/stdcompat__lexing.mli.in \ $(srcdir)/stdcompat__lexing_s.mli.in \ $(srcdir)/stdcompat__list.ml.in \ $(srcdir)/stdcompat__list.mli.in \ $(srcdir)/stdcompat__listLabels.ml.in \ $(srcdir)/stdcompat__listLabels.mli.in \ $(srcdir)/stdcompat__listLabels_s.mli.in \ $(srcdir)/stdcompat__list_s.mli.in \ $(srcdir)/stdcompat__map.ml.in $(srcdir)/stdcompat__map.mli.in \ $(srcdir)/stdcompat__map_s.mli.in \ $(srcdir)/stdcompat__moreLabels.ml.in \ $(srcdir)/stdcompat__moreLabels.mli.in \ $(srcdir)/stdcompat__moreLabels_s.mli.in \ $(srcdir)/stdcompat__native.ml_byte.in \ $(srcdir)/stdcompat__native.ml_native.in \ $(srcdir)/stdcompat__nativeint.ml.in \ $(srcdir)/stdcompat__nativeint.mli.in \ $(srcdir)/stdcompat__nativeint_s.mli.in \ $(srcdir)/stdcompat__option.ml.in \ $(srcdir)/stdcompat__option.mli.in \ $(srcdir)/stdcompat__option_s.mli.in \ $(srcdir)/stdcompat__out_channel.ml.in \ $(srcdir)/stdcompat__out_channel.mli.in \ $(srcdir)/stdcompat__out_channel_s.mli.in \ $(srcdir)/stdcompat__pervasives.ml.in \ $(srcdir)/stdcompat__pervasives.mli.in \ $(srcdir)/stdcompat__pervasives_s.mli.in \ $(srcdir)/stdcompat__printexc.ml.in \ $(srcdir)/stdcompat__printexc.mli.in \ $(srcdir)/stdcompat__printexc_s.mli.in \ $(srcdir)/stdcompat__printf.ml.in \ $(srcdir)/stdcompat__printf.mli.in \ $(srcdir)/stdcompat__printf_s.mli.in \ $(srcdir)/stdcompat__queue.ml.in \ $(srcdir)/stdcompat__queue.mli.in \ $(srcdir)/stdcompat__queue_s.mli.in \ $(srcdir)/stdcompat__random.ml.in \ $(srcdir)/stdcompat__random.mli.in \ $(srcdir)/stdcompat__random_s.mli.in \ $(srcdir)/stdcompat__result.ml.in \ $(srcdir)/stdcompat__result.mli.in \ $(srcdir)/stdcompat__result_s.mli.in \ $(srcdir)/stdcompat__root.ml.in \ $(srcdir)/stdcompat__root.mli.in \ $(srcdir)/stdcompat__seq.ml.in $(srcdir)/stdcompat__seq.mli.in \ $(srcdir)/stdcompat__seq_s.mli.in \ $(srcdir)/stdcompat__set.ml.in $(srcdir)/stdcompat__set.mli.in \ $(srcdir)/stdcompat__set_s.mli.in \ $(srcdir)/stdcompat__stack.ml.in \ $(srcdir)/stdcompat__stack.mli.in \ $(srcdir)/stdcompat__stack_s.mli.in \ $(srcdir)/stdcompat__stdlib.ml.in \ $(srcdir)/stdcompat__stdlib.mli.in \ $(srcdir)/stdcompat__stdlib_s.mli.in \ $(srcdir)/stdcompat__string.ml.in \ $(srcdir)/stdcompat__string.mli.in \ $(srcdir)/stdcompat__stringLabels.ml.in \ $(srcdir)/stdcompat__stringLabels.mli.in \ $(srcdir)/stdcompat__stringLabels_s.mli.in \ $(srcdir)/stdcompat__string_s.mli.in \ $(srcdir)/stdcompat__stubs.c.in $(srcdir)/stdcompat__sys.ml.in \ $(srcdir)/stdcompat__sys.mli.in \ $(srcdir)/stdcompat__sys_s.mli.in \ $(srcdir)/stdcompat__tools.ml.in \ $(srcdir)/stdcompat__tools.mli.in \ $(srcdir)/stdcompat__uchar.ml.in \ $(srcdir)/stdcompat__uchar.mli.in \ $(srcdir)/stdcompat__uchar_s.mli.in \ $(srcdir)/stdcompat__unit.ml.in \ $(srcdir)/stdcompat__unit.mli.in \ $(srcdir)/stdcompat__unit_s.mli.in \ $(srcdir)/stdcompat__weak.ml.in \ $(srcdir)/stdcompat__weak.mli.in \ $(srcdir)/stdcompat__weak_s.mli.in \ $(srcdir)/stdcompat_tests.ml.in AUTHORS COPYING INSTALL NEWS \ README compile install-sh missing DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) am__remove_distdir = \ if test -d "$(distdir)"; then \ find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ && rm -rf "$(distdir)" \ || { sleep 5 && rm -rf "$(distdir)"; }; \ else :; fi am__post_remove_distdir = $(am__remove_distdir) DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = --best DIST_TARGETS = dist-gzip # Exists only to be overridden by the user if desired. AM_DISTCHECK_DVI_TARGET = dvi distuninstallcheck_listfiles = find . -type f -print am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ BEGIN_BEFORE_3_07_0 = @BEGIN_BEFORE_3_07_0@ BEGIN_BEFORE_3_08_0 = @BEGIN_BEFORE_3_08_0@ BEGIN_BEFORE_3_09_0 = @BEGIN_BEFORE_3_09_0@ BEGIN_BEFORE_3_10_0 = @BEGIN_BEFORE_3_10_0@ BEGIN_BEFORE_3_11_0 = @BEGIN_BEFORE_3_11_0@ BEGIN_BEFORE_3_12_0 = @BEGIN_BEFORE_3_12_0@ BEGIN_BEFORE_4_00_0 = @BEGIN_BEFORE_4_00_0@ BEGIN_BEFORE_4_01_0 = @BEGIN_BEFORE_4_01_0@ BEGIN_BEFORE_4_02_0 = @BEGIN_BEFORE_4_02_0@ BEGIN_BEFORE_4_03_0 = @BEGIN_BEFORE_4_03_0@ BEGIN_BEFORE_4_04_0 = @BEGIN_BEFORE_4_04_0@ BEGIN_BEFORE_4_05_0 = @BEGIN_BEFORE_4_05_0@ BEGIN_BEFORE_4_06_0 = @BEGIN_BEFORE_4_06_0@ BEGIN_BEFORE_4_07_0 = @BEGIN_BEFORE_4_07_0@ BEGIN_BEFORE_4_07_1 = @BEGIN_BEFORE_4_07_1@ BEGIN_BEFORE_4_08_0 = @BEGIN_BEFORE_4_08_0@ BEGIN_BEFORE_4_09_0 = @BEGIN_BEFORE_4_09_0@ BEGIN_BEFORE_4_10_0 = @BEGIN_BEFORE_4_10_0@ BEGIN_BEFORE_4_11_0 = @BEGIN_BEFORE_4_11_0@ BEGIN_BEFORE_4_12_0 = @BEGIN_BEFORE_4_12_0@ BEGIN_BEFORE_4_13_0 = @BEGIN_BEFORE_4_13_0@ BEGIN_BEFORE_4_14_0 = @BEGIN_BEFORE_4_14_0@ BEGIN_BEFORE_5_0_0 = @BEGIN_BEFORE_5_0_0@ BEGIN_BEFORE_5_1_0 = @BEGIN_BEFORE_5_1_0@ BEGIN_BEFORE_5_2_0 = @BEGIN_BEFORE_5_2_0@ BEGIN_FROM_3_07_0 = @BEGIN_FROM_3_07_0@ BEGIN_FROM_3_08_0 = @BEGIN_FROM_3_08_0@ BEGIN_FROM_3_09_0 = @BEGIN_FROM_3_09_0@ BEGIN_FROM_3_10_0 = @BEGIN_FROM_3_10_0@ BEGIN_FROM_3_11_0 = @BEGIN_FROM_3_11_0@ BEGIN_FROM_3_12_0 = @BEGIN_FROM_3_12_0@ BEGIN_FROM_4_00_0 = @BEGIN_FROM_4_00_0@ BEGIN_FROM_4_01_0 = @BEGIN_FROM_4_01_0@ BEGIN_FROM_4_02_0 = @BEGIN_FROM_4_02_0@ BEGIN_FROM_4_03_0 = @BEGIN_FROM_4_03_0@ BEGIN_FROM_4_04_0 = @BEGIN_FROM_4_04_0@ BEGIN_FROM_4_05_0 = @BEGIN_FROM_4_05_0@ BEGIN_FROM_4_06_0 = @BEGIN_FROM_4_06_0@ BEGIN_FROM_4_07_0 = @BEGIN_FROM_4_07_0@ BEGIN_FROM_4_07_1 = @BEGIN_FROM_4_07_1@ BEGIN_FROM_4_08_0 = @BEGIN_FROM_4_08_0@ BEGIN_FROM_4_09_0 = @BEGIN_FROM_4_09_0@ BEGIN_FROM_4_10_0 = @BEGIN_FROM_4_10_0@ BEGIN_FROM_4_11_0 = @BEGIN_FROM_4_11_0@ BEGIN_FROM_4_12_0 = @BEGIN_FROM_4_12_0@ BEGIN_FROM_4_13_0 = @BEGIN_FROM_4_13_0@ BEGIN_FROM_4_14_0 = @BEGIN_FROM_4_14_0@ BEGIN_FROM_5_0_0 = @BEGIN_FROM_5_0_0@ BEGIN_FROM_5_1_0 = @BEGIN_FROM_5_1_0@ BEGIN_FROM_5_2_0 = @BEGIN_FROM_5_2_0@ BEGIN_WITHOUT_CYGWIN = @BEGIN_WITHOUT_CYGWIN@ BEGIN_WITHOUT_FLAMBDA2 = @BEGIN_WITHOUT_FLAMBDA2@ BEGIN_WITHOUT_MAGIC = @BEGIN_WITHOUT_MAGIC@ BEGIN_WITHOUT_RESULT_PKG = @BEGIN_WITHOUT_RESULT_PKG@ BEGIN_WITHOUT_SEQ_PKG = @BEGIN_WITHOUT_SEQ_PKG@ BEGIN_WITHOUT_UCHAR_PKG = @BEGIN_WITHOUT_UCHAR_PKG@ BEGIN_WITHOUT_UNIX = @BEGIN_WITHOUT_UNIX@ BEGIN_WITHOUT_WIN32 = @BEGIN_WITHOUT_WIN32@ BEGIN_WITH_CYGWIN = @BEGIN_WITH_CYGWIN@ BEGIN_WITH_FLAMBDA2 = @BEGIN_WITH_FLAMBDA2@ BEGIN_WITH_MAGIC = @BEGIN_WITH_MAGIC@ BEGIN_WITH_RESULT_PKG = @BEGIN_WITH_RESULT_PKG@ BEGIN_WITH_SEQ_PKG = @BEGIN_WITH_SEQ_PKG@ BEGIN_WITH_UCHAR_PKG = @BEGIN_WITH_UCHAR_PKG@ BEGIN_WITH_UNIX = @BEGIN_WITH_UNIX@ BEGIN_WITH_WIN32 = @BEGIN_WITH_WIN32@ BIG_ENDIAN = @BIG_ENDIAN@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CMAX = @CMAX@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ CYGPATH_W = @CYGPATH_W@ C_BEGIN_BEFORE_3_07_0 = @C_BEGIN_BEFORE_3_07_0@ C_BEGIN_BEFORE_3_08_0 = @C_BEGIN_BEFORE_3_08_0@ C_BEGIN_BEFORE_3_09_0 = @C_BEGIN_BEFORE_3_09_0@ C_BEGIN_BEFORE_3_10_0 = @C_BEGIN_BEFORE_3_10_0@ C_BEGIN_BEFORE_3_11_0 = @C_BEGIN_BEFORE_3_11_0@ C_BEGIN_BEFORE_3_12_0 = @C_BEGIN_BEFORE_3_12_0@ C_BEGIN_BEFORE_4_00_0 = @C_BEGIN_BEFORE_4_00_0@ C_BEGIN_BEFORE_4_01_0 = @C_BEGIN_BEFORE_4_01_0@ C_BEGIN_BEFORE_4_02_0 = @C_BEGIN_BEFORE_4_02_0@ C_BEGIN_BEFORE_4_03_0 = @C_BEGIN_BEFORE_4_03_0@ C_BEGIN_BEFORE_4_04_0 = @C_BEGIN_BEFORE_4_04_0@ C_BEGIN_BEFORE_4_05_0 = @C_BEGIN_BEFORE_4_05_0@ C_BEGIN_BEFORE_4_06_0 = @C_BEGIN_BEFORE_4_06_0@ C_BEGIN_BEFORE_4_07_0 = @C_BEGIN_BEFORE_4_07_0@ C_BEGIN_BEFORE_4_07_1 = @C_BEGIN_BEFORE_4_07_1@ C_BEGIN_BEFORE_4_08_0 = @C_BEGIN_BEFORE_4_08_0@ C_BEGIN_BEFORE_4_09_0 = @C_BEGIN_BEFORE_4_09_0@ C_BEGIN_BEFORE_4_10_0 = @C_BEGIN_BEFORE_4_10_0@ C_BEGIN_BEFORE_4_11_0 = @C_BEGIN_BEFORE_4_11_0@ C_BEGIN_BEFORE_4_12_0 = @C_BEGIN_BEFORE_4_12_0@ C_BEGIN_BEFORE_4_13_0 = @C_BEGIN_BEFORE_4_13_0@ C_BEGIN_BEFORE_4_14_0 = @C_BEGIN_BEFORE_4_14_0@ C_BEGIN_BEFORE_5_0_0 = @C_BEGIN_BEFORE_5_0_0@ C_BEGIN_BEFORE_5_1_0 = @C_BEGIN_BEFORE_5_1_0@ C_BEGIN_BEFORE_5_2_0 = @C_BEGIN_BEFORE_5_2_0@ C_BEGIN_FROM_3_07_0 = @C_BEGIN_FROM_3_07_0@ C_BEGIN_FROM_3_08_0 = @C_BEGIN_FROM_3_08_0@ C_BEGIN_FROM_3_09_0 = @C_BEGIN_FROM_3_09_0@ C_BEGIN_FROM_3_10_0 = @C_BEGIN_FROM_3_10_0@ C_BEGIN_FROM_3_11_0 = @C_BEGIN_FROM_3_11_0@ C_BEGIN_FROM_3_12_0 = @C_BEGIN_FROM_3_12_0@ C_BEGIN_FROM_4_00_0 = @C_BEGIN_FROM_4_00_0@ C_BEGIN_FROM_4_01_0 = @C_BEGIN_FROM_4_01_0@ C_BEGIN_FROM_4_02_0 = @C_BEGIN_FROM_4_02_0@ C_BEGIN_FROM_4_03_0 = @C_BEGIN_FROM_4_03_0@ C_BEGIN_FROM_4_04_0 = @C_BEGIN_FROM_4_04_0@ C_BEGIN_FROM_4_05_0 = @C_BEGIN_FROM_4_05_0@ C_BEGIN_FROM_4_06_0 = @C_BEGIN_FROM_4_06_0@ C_BEGIN_FROM_4_07_0 = @C_BEGIN_FROM_4_07_0@ C_BEGIN_FROM_4_07_1 = @C_BEGIN_FROM_4_07_1@ C_BEGIN_FROM_4_08_0 = @C_BEGIN_FROM_4_08_0@ C_BEGIN_FROM_4_09_0 = @C_BEGIN_FROM_4_09_0@ C_BEGIN_FROM_4_10_0 = @C_BEGIN_FROM_4_10_0@ C_BEGIN_FROM_4_11_0 = @C_BEGIN_FROM_4_11_0@ C_BEGIN_FROM_4_12_0 = @C_BEGIN_FROM_4_12_0@ C_BEGIN_FROM_4_13_0 = @C_BEGIN_FROM_4_13_0@ C_BEGIN_FROM_4_14_0 = @C_BEGIN_FROM_4_14_0@ C_BEGIN_FROM_5_0_0 = @C_BEGIN_FROM_5_0_0@ C_BEGIN_FROM_5_1_0 = @C_BEGIN_FROM_5_1_0@ C_BEGIN_FROM_5_2_0 = @C_BEGIN_FROM_5_2_0@ C_BEGIN_WITHOUT_CYGWIN = @C_BEGIN_WITHOUT_CYGWIN@ C_BEGIN_WITHOUT_FLAMBDA2 = @C_BEGIN_WITHOUT_FLAMBDA2@ C_BEGIN_WITHOUT_MAGIC = @C_BEGIN_WITHOUT_MAGIC@ C_BEGIN_WITHOUT_RESULT_PKG = @C_BEGIN_WITHOUT_RESULT_PKG@ C_BEGIN_WITHOUT_SEQ_PKG = @C_BEGIN_WITHOUT_SEQ_PKG@ C_BEGIN_WITHOUT_UCHAR_PKG = @C_BEGIN_WITHOUT_UCHAR_PKG@ C_BEGIN_WITHOUT_UNIX = @C_BEGIN_WITHOUT_UNIX@ C_BEGIN_WITHOUT_WIN32 = @C_BEGIN_WITHOUT_WIN32@ C_BEGIN_WITH_CYGWIN = @C_BEGIN_WITH_CYGWIN@ C_BEGIN_WITH_FLAMBDA2 = @C_BEGIN_WITH_FLAMBDA2@ C_BEGIN_WITH_MAGIC = @C_BEGIN_WITH_MAGIC@ C_BEGIN_WITH_RESULT_PKG = @C_BEGIN_WITH_RESULT_PKG@ C_BEGIN_WITH_SEQ_PKG = @C_BEGIN_WITH_SEQ_PKG@ C_BEGIN_WITH_UCHAR_PKG = @C_BEGIN_WITH_UCHAR_PKG@ C_BEGIN_WITH_UNIX = @C_BEGIN_WITH_UNIX@ C_BEGIN_WITH_WIN32 = @C_BEGIN_WITH_WIN32@ C_END_BEFORE_3_07_0 = @C_END_BEFORE_3_07_0@ C_END_BEFORE_3_08_0 = @C_END_BEFORE_3_08_0@ C_END_BEFORE_3_09_0 = @C_END_BEFORE_3_09_0@ C_END_BEFORE_3_10_0 = @C_END_BEFORE_3_10_0@ C_END_BEFORE_3_11_0 = @C_END_BEFORE_3_11_0@ C_END_BEFORE_3_12_0 = @C_END_BEFORE_3_12_0@ C_END_BEFORE_4_00_0 = @C_END_BEFORE_4_00_0@ C_END_BEFORE_4_01_0 = @C_END_BEFORE_4_01_0@ C_END_BEFORE_4_02_0 = @C_END_BEFORE_4_02_0@ C_END_BEFORE_4_03_0 = @C_END_BEFORE_4_03_0@ C_END_BEFORE_4_04_0 = @C_END_BEFORE_4_04_0@ C_END_BEFORE_4_05_0 = @C_END_BEFORE_4_05_0@ C_END_BEFORE_4_06_0 = @C_END_BEFORE_4_06_0@ C_END_BEFORE_4_07_0 = @C_END_BEFORE_4_07_0@ C_END_BEFORE_4_07_1 = @C_END_BEFORE_4_07_1@ C_END_BEFORE_4_08_0 = @C_END_BEFORE_4_08_0@ C_END_BEFORE_4_09_0 = @C_END_BEFORE_4_09_0@ C_END_BEFORE_4_10_0 = @C_END_BEFORE_4_10_0@ C_END_BEFORE_4_11_0 = @C_END_BEFORE_4_11_0@ C_END_BEFORE_4_12_0 = @C_END_BEFORE_4_12_0@ C_END_BEFORE_4_13_0 = @C_END_BEFORE_4_13_0@ C_END_BEFORE_4_14_0 = @C_END_BEFORE_4_14_0@ C_END_BEFORE_5_0_0 = @C_END_BEFORE_5_0_0@ C_END_BEFORE_5_1_0 = @C_END_BEFORE_5_1_0@ C_END_BEFORE_5_2_0 = @C_END_BEFORE_5_2_0@ C_END_FROM_3_07_0 = @C_END_FROM_3_07_0@ C_END_FROM_3_08_0 = @C_END_FROM_3_08_0@ C_END_FROM_3_09_0 = @C_END_FROM_3_09_0@ C_END_FROM_3_10_0 = @C_END_FROM_3_10_0@ C_END_FROM_3_11_0 = @C_END_FROM_3_11_0@ C_END_FROM_3_12_0 = @C_END_FROM_3_12_0@ C_END_FROM_4_00_0 = @C_END_FROM_4_00_0@ C_END_FROM_4_01_0 = @C_END_FROM_4_01_0@ C_END_FROM_4_02_0 = @C_END_FROM_4_02_0@ C_END_FROM_4_03_0 = @C_END_FROM_4_03_0@ C_END_FROM_4_04_0 = @C_END_FROM_4_04_0@ C_END_FROM_4_05_0 = @C_END_FROM_4_05_0@ C_END_FROM_4_06_0 = @C_END_FROM_4_06_0@ C_END_FROM_4_07_0 = @C_END_FROM_4_07_0@ C_END_FROM_4_07_1 = @C_END_FROM_4_07_1@ C_END_FROM_4_08_0 = @C_END_FROM_4_08_0@ C_END_FROM_4_09_0 = @C_END_FROM_4_09_0@ C_END_FROM_4_10_0 = @C_END_FROM_4_10_0@ C_END_FROM_4_11_0 = @C_END_FROM_4_11_0@ C_END_FROM_4_12_0 = @C_END_FROM_4_12_0@ C_END_FROM_4_13_0 = @C_END_FROM_4_13_0@ C_END_FROM_4_14_0 = @C_END_FROM_4_14_0@ C_END_FROM_5_0_0 = @C_END_FROM_5_0_0@ C_END_FROM_5_1_0 = @C_END_FROM_5_1_0@ C_END_FROM_5_2_0 = @C_END_FROM_5_2_0@ C_END_WITHOUT_CYGWIN = @C_END_WITHOUT_CYGWIN@ C_END_WITHOUT_FLAMBDA2 = @C_END_WITHOUT_FLAMBDA2@ C_END_WITHOUT_MAGIC = @C_END_WITHOUT_MAGIC@ C_END_WITHOUT_RESULT_PKG = @C_END_WITHOUT_RESULT_PKG@ C_END_WITHOUT_SEQ_PKG = @C_END_WITHOUT_SEQ_PKG@ C_END_WITHOUT_UCHAR_PKG = @C_END_WITHOUT_UCHAR_PKG@ C_END_WITHOUT_UNIX = @C_END_WITHOUT_UNIX@ C_END_WITHOUT_WIN32 = @C_END_WITHOUT_WIN32@ C_END_WITH_CYGWIN = @C_END_WITH_CYGWIN@ C_END_WITH_FLAMBDA2 = @C_END_WITH_FLAMBDA2@ C_END_WITH_MAGIC = @C_END_WITH_MAGIC@ C_END_WITH_RESULT_PKG = @C_END_WITH_RESULT_PKG@ C_END_WITH_SEQ_PKG = @C_END_WITH_SEQ_PKG@ C_END_WITH_UCHAR_PKG = @C_END_WITH_UCHAR_PKG@ C_END_WITH_UNIX = @C_END_WITH_UNIX@ C_END_WITH_WIN32 = @C_END_WITH_WIN32@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ END_BEFORE_3_07_0 = @END_BEFORE_3_07_0@ END_BEFORE_3_08_0 = @END_BEFORE_3_08_0@ END_BEFORE_3_09_0 = @END_BEFORE_3_09_0@ END_BEFORE_3_10_0 = @END_BEFORE_3_10_0@ END_BEFORE_3_11_0 = @END_BEFORE_3_11_0@ END_BEFORE_3_12_0 = @END_BEFORE_3_12_0@ END_BEFORE_4_00_0 = @END_BEFORE_4_00_0@ END_BEFORE_4_01_0 = @END_BEFORE_4_01_0@ END_BEFORE_4_02_0 = @END_BEFORE_4_02_0@ END_BEFORE_4_03_0 = @END_BEFORE_4_03_0@ END_BEFORE_4_04_0 = @END_BEFORE_4_04_0@ END_BEFORE_4_05_0 = @END_BEFORE_4_05_0@ END_BEFORE_4_06_0 = @END_BEFORE_4_06_0@ END_BEFORE_4_07_0 = @END_BEFORE_4_07_0@ END_BEFORE_4_07_1 = @END_BEFORE_4_07_1@ END_BEFORE_4_08_0 = @END_BEFORE_4_08_0@ END_BEFORE_4_09_0 = @END_BEFORE_4_09_0@ END_BEFORE_4_10_0 = @END_BEFORE_4_10_0@ END_BEFORE_4_11_0 = @END_BEFORE_4_11_0@ END_BEFORE_4_12_0 = @END_BEFORE_4_12_0@ END_BEFORE_4_13_0 = @END_BEFORE_4_13_0@ END_BEFORE_4_14_0 = @END_BEFORE_4_14_0@ END_BEFORE_5_0_0 = @END_BEFORE_5_0_0@ END_BEFORE_5_1_0 = @END_BEFORE_5_1_0@ END_BEFORE_5_2_0 = @END_BEFORE_5_2_0@ END_FROM_3_07_0 = @END_FROM_3_07_0@ END_FROM_3_08_0 = @END_FROM_3_08_0@ END_FROM_3_09_0 = @END_FROM_3_09_0@ END_FROM_3_10_0 = @END_FROM_3_10_0@ END_FROM_3_11_0 = @END_FROM_3_11_0@ END_FROM_3_12_0 = @END_FROM_3_12_0@ END_FROM_4_00_0 = @END_FROM_4_00_0@ END_FROM_4_01_0 = @END_FROM_4_01_0@ END_FROM_4_02_0 = @END_FROM_4_02_0@ END_FROM_4_03_0 = @END_FROM_4_03_0@ END_FROM_4_04_0 = @END_FROM_4_04_0@ END_FROM_4_05_0 = @END_FROM_4_05_0@ END_FROM_4_06_0 = @END_FROM_4_06_0@ END_FROM_4_07_0 = @END_FROM_4_07_0@ END_FROM_4_07_1 = @END_FROM_4_07_1@ END_FROM_4_08_0 = @END_FROM_4_08_0@ END_FROM_4_09_0 = @END_FROM_4_09_0@ END_FROM_4_10_0 = @END_FROM_4_10_0@ END_FROM_4_11_0 = @END_FROM_4_11_0@ END_FROM_4_12_0 = @END_FROM_4_12_0@ END_FROM_4_13_0 = @END_FROM_4_13_0@ END_FROM_4_14_0 = @END_FROM_4_14_0@ END_FROM_5_0_0 = @END_FROM_5_0_0@ END_FROM_5_1_0 = @END_FROM_5_1_0@ END_FROM_5_2_0 = @END_FROM_5_2_0@ END_WITHOUT_CYGWIN = @END_WITHOUT_CYGWIN@ END_WITHOUT_FLAMBDA2 = @END_WITHOUT_FLAMBDA2@ END_WITHOUT_MAGIC = @END_WITHOUT_MAGIC@ END_WITHOUT_RESULT_PKG = @END_WITHOUT_RESULT_PKG@ END_WITHOUT_SEQ_PKG = @END_WITHOUT_SEQ_PKG@ END_WITHOUT_UCHAR_PKG = @END_WITHOUT_UCHAR_PKG@ END_WITHOUT_UNIX = @END_WITHOUT_UNIX@ END_WITHOUT_WIN32 = @END_WITHOUT_WIN32@ END_WITH_CYGWIN = @END_WITH_CYGWIN@ END_WITH_FLAMBDA2 = @END_WITH_FLAMBDA2@ END_WITH_MAGIC = @END_WITH_MAGIC@ END_WITH_RESULT_PKG = @END_WITH_RESULT_PKG@ END_WITH_SEQ_PKG = @END_WITH_SEQ_PKG@ END_WITH_UCHAR_PKG = @END_WITH_UCHAR_PKG@ END_WITH_UNIX = @END_WITH_UNIX@ END_WITH_WIN32 = @END_WITH_WIN32@ ETAGS = @ETAGS@ EXEEXT = @EXEEXT@ INCLUDE_DEPEND = @INCLUDE_DEPEND@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LTLIBOBJS = @LTLIBOBJS@ MAINT = @MAINT@ MAKEINFO = @MAKEINFO@ MKDIR_P = @MKDIR_P@ OBJEXT = @OBJEXT@ OCAML = @OCAML@ OCAMLBEST = @OCAMLBEST@ OCAMLC = @OCAMLC@ OCAMLDEP = @OCAMLDEP@ OCAMLDOC = @OCAMLDOC@ OCAMLFIND = @OCAMLFIND@ OCAMLMKLIB = @OCAMLMKLIB@ OCAMLOPT = @OCAMLOPT@ OCAMLVERSION = @OCAMLVERSION@ OCAML_DEVELOPMENT_VERSION = @OCAML_DEVELOPMENT_VERSION@ OCAML_FLAMBDA2 = @OCAML_FLAMBDA2@ OCAML_RELEASE_EXTRA = @OCAML_RELEASE_EXTRA@ OCAML_RELEASE_EXTRA_PREFIX = @OCAML_RELEASE_EXTRA_PREFIX@ OCAML_RELEASE_EXTRA_PREFIX_CHAR = @OCAML_RELEASE_EXTRA_PREFIX_CHAR@ OCAML_VERSION_MAJOR = @OCAML_VERSION_MAJOR@ OCAML_VERSION_MINOR = @OCAML_VERSION_MINOR@ OCAML_VERSION_PATCHLEVEL = @OCAML_VERSION_PATCHLEVEL@ OCAML_VERSION_PATCH_AND_EXTRA = @OCAML_VERSION_PATCH_AND_EXTRA@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RESULT_PKG = @RESULT_PKG@ SEQ_PKG = @SEQ_PKG@ SET_MAKE = @SET_MAKE@ SHARED_LIBS = @SHARED_LIBS@ SHELL = @SHELL@ STRIP = @STRIP@ UCHAR_PKG = @UCHAR_PKG@ VERSION = @VERSION@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build_alias = @build_alias@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ enable_magic = @enable_magic@ exec_prefix = @exec_prefix@ host_alias = @host_alias@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ runstatedir = @runstatedir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ target_os_type = @target_os_type@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ mypkgdir = $(pkglibdir) EXTRA_DIST = stdcompat.opam dune stdcompat.ml stdcompat__native.ml_byte \ stdcompat__native.ml_native stdcompat_tests.ml stdcompat__native.mli \ stdcompat__pervasives.mli stdcompat__arg.mli stdcompat__lazy.mli \ stdcompat__char.mli stdcompat__uchar.mli stdcompat__sys.mli stdcompat__buffer.mli \ stdcompat__string.mli stdcompat__stringLabels.mli stdcompat__bytes.mli \ stdcompat__bytesLabels.mli stdcompat__list.mli \ stdcompat__listLabels.mli \ stdcompat__stack.mli \ stdcompat__hashtbl.mli stdcompat__set.mli \ stdcompat__map.mli stdcompat__weak.mli \ stdcompat__digest.mli stdcompat__nativeint.mli \ stdcompat__int.mli \ stdcompat__int64.mli stdcompat__int32.mli stdcompat__filename.mli \ stdcompat__array.mli stdcompat__arrayLabels.mli \ stdcompat__float.mli stdcompat__queue.mli stdcompat__ephemeron.mli \ stdcompat__moreLabels.mli stdcompat__lexing.mli \ stdcompat__option.mli stdcompat__printexc.mli \ stdcompat__random.mli \ stdcompat__result.mli stdcompat__bool.mli stdcompat__domain.mli \ stdcompat__fun.mli stdcompat__format.mli stdcompat__printf.mli stdcompat__stdlib.mli \ stdcompat__seq.mli stdcompat__printexc.mli \ stdcompat__either.mli stdcompat__atomic.mli \ stdcompat__unit.mli \ stdcompat__in_channel.mli stdcompat__out_channel.mli Makefile.bootstrap VERSION \ dune-project dune MODULES = stdcompat__init.ml stdcompat__root.ml \ stdcompat__either_s.ml stdcompat__either.ml \ stdcompat__seq_s.ml \ stdcompat__seq.ml stdcompat__tools.ml \ stdcompat__pervasives_s.ml stdcompat__arg_s.ml stdcompat__lazy_s.ml \ stdcompat__char_s.ml stdcompat__uchar_s.ml stdcompat__uchar.ml \ stdcompat__buffer_s.ml \ stdcompat__string_s.ml stdcompat__stringLabels_s.ml stdcompat__bytes_s.ml \ stdcompat__bytesLabels_s.ml \ stdcompat__list_s.ml \ stdcompat__listLabels_s.ml \ stdcompat__stack_s.ml \ stdcompat__list.ml \ stdcompat__hashtbl_ext.ml stdcompat__hashtbl_s.ml stdcompat__set_s.ml \ stdcompat__map_s.ml stdcompat__weak_s.ml stdcompat__sys_s.ml \ stdcompat__digest_s.ml stdcompat__nativeint_s.ml \ stdcompat__int_s.ml \ stdcompat__int64_s.ml stdcompat__int32_s.ml stdcompat__filename_s.ml \ stdcompat__array_s.ml stdcompat__arrayLabels_s.ml \ stdcompat__float_s.ml stdcompat__queue_s.ml \ stdcompat__hashtbl.ml \ stdcompat__ephemeron_s.ml \ stdcompat__moreLabels_s.ml stdcompat__lexing_s.ml \ stdcompat__pervasives.ml \ stdcompat__option_s.ml stdcompat__result_s.ml stdcompat__bool_s.ml \ stdcompat__fun_s.ml stdcompat__printf_s.ml stdcompat__domain_s.ml \ stdcompat__domain.ml \ stdcompat__printexc_s.ml stdcompat__format_s.ml stdcompat__atomic_s.ml \ stdcompat__in_channel_s.ml stdcompat__out_channel_s.ml \ stdcompat__random_s.ml \ stdcompat__unit_s.ml \ stdcompat__stdlib_s.ml \ stdcompat__arg.ml stdcompat__lazy.ml \ stdcompat__char.ml \ stdcompat__option.ml \ stdcompat__buffer.ml stdcompat__sys.ml \ stdcompat__bytes.ml stdcompat__bytesLabels.ml \ stdcompat__string.ml stdcompat__stringLabels.ml \ stdcompat__filename.ml \ stdcompat__listLabels.ml \ stdcompat__stack.ml stdcompat__set.ml \ stdcompat__map.ml stdcompat__weak.ml \ stdcompat__random.ml \ stdcompat__digest.ml stdcompat__nativeint.ml \ stdcompat__int.ml stdcompat__int64.ml stdcompat__int32.ml \ stdcompat__array.ml stdcompat__arrayLabels.ml \ stdcompat__float.ml stdcompat__queue.ml stdcompat__ephemeron.ml \ stdcompat__moreLabels.ml stdcompat__lexing.ml \ stdcompat__printexc.ml stdcompat__result.ml stdcompat__bool.ml \ stdcompat__fun.ml stdcompat__format.ml stdcompat__printf.ml \ stdcompat__atomic.ml \ stdcompat__in_channel.ml stdcompat__out_channel.ml \ stdcompat__unit.ml \ stdcompat__stdlib.ml stdcompat.ml # From https://github.com/fdopen/opam-repository-mingw/commit/3b4c52e17cfae96cfbf5120b60b8c2bbf5aad252 # We prefer DLLEXT to conform with EXEEXT and OBJEXT DLLEXT := $(shell ocamlc -config | awk -F '[\t\r ]+' '/^ext_dll:/ {print $$2}') # Fix install on Windows (https://github.com/thierry-martinez/pyml/issues/88) LIBEXT := $(shell ocamlc -config | awk -F '[\t\r ]+' '/^ext_lib:/ {print $$2}') MODULES_native = stdcompat__native.ml $(MODULES) mypkg_SCRIPTS = META $(MODULES_native) $(MODULES_native:.ml=.cmi) \ libstdcompat__stubs$(LIBEXT) stdcompat.h $(am__append_1) \ $(am__append_2) $(am__append_3) $(am__append_5) @OCAML_SUPPORTS_BYTECODE_TRUE@BEST_SUFFIX := .cmo @OCAML_SUPPORTS_NATIVE_TRUE@BEST_SUFFIX := .cmx PACKAGES = $(RESULT_PKG) $(SEQ_PKG) $(UCHAR_PKG) OCAMLFLAGS = $(PACKAGES:%=-package %) $(am__append_4) $(am__append_6) OCAMLCFLAGS = $(OCAMLFLAGS) -nolabels -I @srcdir@ $(am__append_7) OCAMLLDFLAGS = $(OCAMLFLAGS) OCAMLLIBFLAGS = -cclib "-L. -lstdcompat__stubs" STDCOMPAT_TESTS_EXE = stdcompat_tests$(EXEEXT) SUFFIXES = .ml .mli .cmi .cmo .cmx .cmxa .cmxs .cmt .DEFAULT_GOAL = all CLEANFILES = *.cmi *.cmo *.cmx *.cmt *.cmti *.$(OBJEXT) *$(LIBEXT) stdcompat.cma \ stdcompat.cmxa stdcompat__native.ml dllstdcompat__stubs$(DLLEXT) \ stdcompat.cmxs $(STDCOMPAT_TESTS_EXE) $(bin_SCRIPTS) .depend all: config.h $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: .SUFFIXES: .ml .mli .cmi .cmo .cmx .cmxa .cmxs .cmt am--refresh: Makefile @: $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ echo ' $(SHELL) ./config.status'; \ $(SHELL) ./config.status;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) $(SHELL) ./config.status --recheck $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) $(am__cd) $(srcdir) && $(AUTOCONF) $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) $(am__aclocal_m4_deps): config.h: stamp-h1 @test -f $@ || rm -f stamp-h1 @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1 stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status @rm -f stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status config.h $(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) rm -f stamp-h1 touch $@ distclean-hdr: -rm -f config.h stamp-h1 META: $(top_builddir)/config.status $(srcdir)/META.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__hashtbl_ext.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__hashtbl_ext.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__hashtbl_ext.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__hashtbl_ext.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__init.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__init.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__init.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__init.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__root.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__root.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__root.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__root.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__tools.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__tools.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__tools.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__tools.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__native.ml_byte: $(top_builddir)/config.status $(srcdir)/stdcompat__native.ml_byte.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__native.ml_native: $(top_builddir)/config.status $(srcdir)/stdcompat__native.ml_native.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat_tests.ml: $(top_builddir)/config.status $(srcdir)/stdcompat_tests.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat.h: $(top_builddir)/config.status $(srcdir)/stdcompat.h.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stubs.c: $(top_builddir)/config.status $(srcdir)/stdcompat__stubs.c.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__pervasives_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__pervasives_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arg_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__arg_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__array_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__array_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arrayLabels_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__arrayLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__atomic_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__atomic_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bool_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__bool_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__buffer_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__buffer_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytes_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__bytes_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytesLabels_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__bytesLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__char_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__char_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__digest_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__digest_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__domain_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__domain_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__either_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__either_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__ephemeron_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__ephemeron_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__filename_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__filename_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__float_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__float_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__format_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__format_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__fun_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__fun_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__hashtbl_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__hashtbl_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__in_channel_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__in_channel_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__int_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int32_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__int32_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int64_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__int64_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lazy_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__lazy_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lexing_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__lexing_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__list_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__list_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__listLabels_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__listLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__map_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__map_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__moreLabels_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__moreLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__nativeint_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__nativeint_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__option_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__option_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__out_channel_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__out_channel_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printexc_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__printexc_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printf_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__printf_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__queue_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__queue_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__random_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__random_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__result_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__result_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__seq_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__seq_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__set_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__set_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stack_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__stack_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__string_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__string_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stringLabels_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__stringLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__sys_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__sys_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__uchar_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__uchar_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__weak_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__weak_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__unit_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__unit_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stdlib_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__stdlib_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__pervasives_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__pervasives_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arg_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__arg_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__array_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__array_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arrayLabels_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__arrayLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__atomic_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__atomic_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bool_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__bool_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__buffer_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__buffer_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytes_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__bytes_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytesLabels_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__bytesLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__char_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__char_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__digest_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__digest_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__domain_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__domain_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__either_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__either_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__ephemeron_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__ephemeron_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__filename_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__filename_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__float_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__float_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__format_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__format_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__fun_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__fun_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__hashtbl_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__hashtbl_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__int_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int32_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__int32_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int64_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__int64_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lazy_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__lazy_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lexing_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__lexing_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__list_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__list_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__listLabels_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__listLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__map_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__map_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__moreLabels_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__moreLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__nativeint_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__nativeint_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__option_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__option_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printexc_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__printexc_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printf_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__printf_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__queue_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__queue_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__random_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__random_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__result_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__result_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__seq_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__seq_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__set_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__set_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stack_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__stack_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stdlib_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__stdlib_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__string_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__string_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stringLabels_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__stringLabels_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__sys_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__sys_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__uchar_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__uchar_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__weak_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__weak_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__in_channel_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__in_channel_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__out_channel_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__out_channel_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__unit_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__unit_s.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__pervasives.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__pervasives.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arg.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__arg.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__array.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__array.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arrayLabels.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__arrayLabels.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__atomic.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__atomic.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bool.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__bool.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__buffer.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__buffer.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytes.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__bytes.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytesLabels.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__bytesLabels.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__char.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__char.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__digest.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__digest.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__domain.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__domain.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__either.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__either.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__ephemeron.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__ephemeron.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__filename.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__filename.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__float.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__float.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__format.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__format.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__fun.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__fun.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__hashtbl.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__hashtbl.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__int.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int32.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__int32.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int64.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__int64.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lazy.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__lazy.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lexing.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__lexing.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__list.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__list.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__listLabels.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__listLabels.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__map.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__map.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__moreLabels.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__moreLabels.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__nativeint.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__nativeint.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__option.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__option.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printexc.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__printexc.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printf.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__printf.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__queue.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__queue.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__random.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__random.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__result.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__result.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__seq.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__seq.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__set.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__set.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stack.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__stack.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stdlib.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__stdlib.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__string.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__string.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stringLabels.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__stringLabels.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__sys.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__sys.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__uchar.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__uchar.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__weak.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__weak.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__in_channel.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__in_channel.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__out_channel.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__out_channel.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__unit.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__unit.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__pervasives.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__pervasives.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arg.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__arg.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__array.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__array.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__arrayLabels.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__arrayLabels.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__atomic.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__atomic.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bool.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__bool.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__buffer.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__buffer.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytes.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__bytes.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__bytesLabels.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__bytesLabels.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__char.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__char.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__digest.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__digest.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__domain.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__domain.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__either.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__either.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__ephemeron.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__ephemeron.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__filename.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__filename.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__float.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__float.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__format.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__format.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__fun.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__fun.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__hashtbl.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__hashtbl.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__int.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int32.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__int32.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__int64.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__int64.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lazy.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__lazy.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__lexing.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__lexing.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__list.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__list.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__listLabels.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__listLabels.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__map.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__map.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__moreLabels.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__moreLabels.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__nativeint.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__nativeint.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__option.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__option.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printexc.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__printexc.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__printf.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__printf.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__queue.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__queue.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__random.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__random.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__result.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__result.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__seq.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__seq.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__set.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__set.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stack.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__stack.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stdlib.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__stdlib.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__string.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__string.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__stringLabels.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__stringLabels.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__sys.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__sys.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__uchar.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__uchar.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__weak.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__weak.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__in_channel.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__in_channel.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__out_channel.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__out_channel.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat__unit.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__unit.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat.mli: $(top_builddir)/config.status $(srcdir)/stdcompat.mli.in cd $(top_builddir) && $(SHELL) ./config.status $@ stdcompat.ml: $(top_builddir)/config.status $(srcdir)/stdcompat.ml.in cd $(top_builddir) && $(SHELL) ./config.status $@ install-mypkgSCRIPTS: $(mypkg_SCRIPTS) @$(NORMAL_INSTALL) @list='$(mypkg_SCRIPTS)'; test -n "$(mypkgdir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(mypkgdir)'"; \ $(MKDIR_P) "$(DESTDIR)$(mypkgdir)" || exit 1; \ fi; \ for p in $$list; do \ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ if test -f "$$d$$p"; then echo "$$d$$p"; echo "$$p"; else :; fi; \ done | \ sed -e 'p;s,.*/,,;n' \ -e 'h;s|.*|.|' \ -e 'p;x;s,.*/,,;$(transform)' | sed 'N;N;N;s,\n, ,g' | \ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1; } \ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ if ($$2 == $$4) { files[d] = files[d] " " $$1; \ if (++n[d] == $(am__install_max)) { \ print "f", d, files[d]; n[d] = 0; files[d] = "" } } \ else { print "f", d "/" $$4, $$1 } } \ END { for (d in files) print "f", d, files[d] }' | \ while read type dir files; do \ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ test -z "$$files" || { \ echo " $(INSTALL_SCRIPT) $$files '$(DESTDIR)$(mypkgdir)$$dir'"; \ $(INSTALL_SCRIPT) $$files "$(DESTDIR)$(mypkgdir)$$dir" || exit $$?; \ } \ ; done uninstall-mypkgSCRIPTS: @$(NORMAL_UNINSTALL) @list='$(mypkg_SCRIPTS)'; test -n "$(mypkgdir)" || exit 0; \ files=`for p in $$list; do echo "$$p"; done | \ sed -e 's,.*/,,;$(transform)'`; \ dir='$(DESTDIR)$(mypkgdir)'; $(am__uninstall_files_from_dir) ID: $(am__tagged_files) $(am__define_uniq_tagged_files); mkid -fID $$unique tags: tags-am TAGS: tags tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set x; \ here=`pwd`; \ $(am__define_uniq_tagged_files); \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ if test $$# -gt 0; then \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ "$$@" $$unique; \ else \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ $$unique; \ fi; \ fi ctags: ctags-am CTAGS: ctags ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $(am__define_uniq_tagged_files); \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" cscope: cscope.files test ! -s cscope.files \ || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) clean-cscope: -rm -f cscope.files cscope.files: clean-cscope cscopelist cscopelist: cscopelist-am cscopelist-am: $(am__tagged_files) list='$(am__tagged_files)'; \ case "$(srcdir)" in \ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ *) sdir=$(subdir)/$(srcdir) ;; \ esac; \ for i in $$list; do \ if test -f "$$i"; then \ echo "$(subdir)/$$i"; \ else \ echo "$$sdir/$$i"; \ fi; \ done >> $(top_builddir)/cscope.files distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags -rm -f cscope.out cscope.in.out cscope.po.out cscope.files distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(DISTFILES) $(am__remove_distdir) test -d "$(distdir)" || mkdir "$(distdir)" @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done -test -n "$(am__skip_mode_fix)" \ || find "$(distdir)" -type d ! -perm -755 \ -exec chmod u+rwx,go+rx {} \; -o \ ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ || chmod -R a+r "$(distdir)" dist-gzip: distdir tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz $(am__post_remove_distdir) dist-bzip2: distdir tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 $(am__post_remove_distdir) dist-lzip: distdir tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz $(am__post_remove_distdir) dist-xz: distdir tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz $(am__post_remove_distdir) dist-zstd: distdir tardir=$(distdir) && $(am__tar) | zstd -c $${ZSTD_CLEVEL-$${ZSTD_OPT--19}} >$(distdir).tar.zst $(am__post_remove_distdir) dist-tarZ: distdir @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz $(am__post_remove_distdir) dist-zip: distdir -rm -f $(distdir).zip zip -rq $(distdir).zip $(distdir) $(am__post_remove_distdir) dist dist-all: $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' $(am__post_remove_distdir) # This target untars the dist file and tries a VPATH configuration. Then # it guarantees that the distribution is self-contained by making another # tarfile. distcheck: dist case '$(DIST_ARCHIVES)' in \ *.tar.gz*) \ eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ *.tar.lz*) \ lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ *.tar.xz*) \ xz -dc $(distdir).tar.xz | $(am__untar) ;;\ *.tar.Z*) \ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ *.shar.gz*) \ eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ *.tar.zst*) \ zstd -dc $(distdir).tar.zst | $(am__untar) ;;\ esac chmod -R a-w $(distdir) chmod u+w $(distdir) mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst chmod a-w $(distdir) test -d $(distdir)/_build || exit 0; \ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ && am__cwd=`pwd` \ && $(am__cd) $(distdir)/_build/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(MAKE) $(AM_MAKEFLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) $(AM_DISTCHECK_DVI_TARGET) \ && $(MAKE) $(AM_MAKEFLAGS) check \ && $(MAKE) $(AM_MAKEFLAGS) install \ && $(MAKE) $(AM_MAKEFLAGS) installcheck \ && $(MAKE) $(AM_MAKEFLAGS) uninstall \ && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ distuninstallcheck \ && chmod -R a-w "$$dc_install_base" \ && ({ \ (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ } || { rm -rf "$$dc_destdir"; exit 1; }) \ && rm -rf "$$dc_destdir" \ && $(MAKE) $(AM_MAKEFLAGS) dist \ && rm -rf $(DIST_ARCHIVES) \ && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ && cd "$$am__cwd" \ || exit 1 $(am__post_remove_distdir) @(echo "$(distdir) archives ready for distribution: "; \ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' distuninstallcheck: @test -n '$(distuninstallcheck_dir)' || { \ echo 'ERROR: trying to run $@ with an empty' \ '$$(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ $(am__cd) '$(distuninstallcheck_dir)' || { \ echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left after uninstall:" ; \ if test -n "$(DESTDIR)"; then \ echo " (check DESTDIR support)"; \ fi ; \ $(distuninstallcheck_listfiles) ; \ exit 1; } >&2 distcleancheck: distclean @if test '$(srcdir)' = . ; then \ echo "ERROR: distcleancheck can only run from a VPATH build" ; \ exit 1 ; \ fi @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left in build directory after distclean:" ; \ $(distcleancheck_listfiles) ; \ exit 1; } >&2 check-am: all-am check: check-am all-am: Makefile $(SCRIPTS) config.h installdirs: for dir in "$(DESTDIR)$(mypkgdir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: clean-generic: -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-am clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -f Makefile distclean-am: clean-am distclean-generic distclean-hdr distclean-tags dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-mypkgSCRIPTS install-dvi: install-dvi-am install-dvi-am: install-exec-am: @$(NORMAL_INSTALL) $(MAKE) $(AM_MAKEFLAGS) install-exec-hook install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: uninstall-mypkgSCRIPTS .MAKE: all install-am install-exec-am install-strip .PHONY: CTAGS GTAGS TAGS all all-am am--refresh check check-am clean \ clean-cscope clean-generic cscope cscopelist-am ctags ctags-am \ dist dist-all dist-bzip2 dist-gzip dist-lzip dist-shar \ dist-tarZ dist-xz dist-zip dist-zstd distcheck distclean \ distclean-generic distclean-hdr distclean-tags distcleancheck \ distdir distuninstallcheck dvi dvi-am html html-am info \ info-am install install-am install-data install-data-am \ install-dvi install-dvi-am install-exec install-exec-am \ install-exec-hook install-html install-html-am install-info \ install-info-am install-man install-mypkgSCRIPTS install-pdf \ install-pdf-am install-ps install-ps-am install-strip \ installcheck installcheck-am installdirs maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ pdf-am ps ps-am tags tags-am uninstall uninstall-am \ uninstall-mypkgSCRIPTS .PRECIOUS: Makefile .mli.cmi : $(OCAMLBEST) -c $(OCAMLCFLAGS) $< -o $@ .ml.cmo : $(OCAMLC) -c $(OCAMLCFLAGS) $< -o $@ .ml.cmx : $(OCAMLOPT) -c $(OCAMLCFLAGS) $< -o $@ $(BEST_SUFFIX).cmt : ; stdcompat__stubs.$(OBJEXT) : stdcompat__stubs.c $(OCAMLC) -c $< libstdcompat__stubs$(LIBEXT) : stdcompat__stubs.$(OBJEXT) $(OCAMLMKLIB) -o stdcompat__stubs $< dllstdcompat__stubs$(DLLEXT) : libstdcompat__stubs$(LIBEXT) stdcompat.cma : $(MODULES_native:.ml=.cmo) libstdcompat__stubs$(LIBEXT) $(OCAMLC) $(OCAMLLDFLAGS) -a $(MODULES_native:.ml=.cmo) \ $(OCAMLLIBFLAGS) -dllib -lstdcompat__stubs -o $@ stdcompat.cmxa : $(MODULES_native:.ml=.cmx) libstdcompat__stubs$(LIBEXT) $(OCAMLOPT) $(OCAMLLDFLAGS) -a $(MODULES_native:.ml=.cmx) $(OCAMLLIBFLAGS) -o $@ stdcompat$(LIBEXT) : stdcompat.cmxa stdcompat.cmxs : $(MODULES_native:.ml=.cmx) libstdcompat__stubs$(LIBEXT) $(OCAMLOPT) $(OCAMLLDFLAGS) -shared $(MODULES_native:.ml=.cmx) $(OCAMLLIBFLAGS) -o $@ # Fake dependency to rebuild stdcompat__native.cmi on compiler change stdcompat__native.cmi : config.status stdcompat__native.cmo : stdcompat__native.ml_byte stdcompat__native.cmi $(OCAMLC) $(OCAMLCFLAGS) -c -impl stdcompat__native.ml_byte stdcompat__native.cmx : stdcompat__native.ml_native stdcompat__native.cmi $(OCAMLOPT) $(OCAMLCFLAGS) -c -impl stdcompat__native.ml_native .PHONY : depend depend : .depend .depend : $(MODULES) $(MODULES_native:.ml=.mli) stdcompat.ml stdcompat__native.ml_byte cp stdcompat__native.ml_byte stdcompat__native.ml $(OCAMLDEP) $^ >$@ || rm -f .depend .PHONY : test test : $(STDCOMPAT_TESTS_EXE) ./$(STDCOMPAT_TESTS_EXE) $(STDCOMPAT_TESTS_EXE): stdcompat.$(CMAX) stdcompat_tests.ml $(OCAMLBEST) stdcompat.$(CMAX) stdcompat_tests.ml -o $@ @INCLUDE_DEPEND@ install-exec-hook : $(MKDIR_P) $(DESTDIR)$(libdir)/stublibs $(INSTALL_PROGRAM) dllstdcompat__stubs$(DLLEXT) $(DESTDIR)$(libdir)/stublibs echo stdcompat >$(DESTDIR)$(libdir)/stublibs/dllstdcompat__stubs$(DLLEXT).owner # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: ocaml-stdcompat-20~git20240529/NEWS000066400000000000000000000000151463722102200166100ustar00rootroot00000000000000See ChangeLogocaml-stdcompat-20~git20240529/README000077700000000000000000000000001463722102200202472README.mdustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/README.md000066400000000000000000000105751463722102200174040ustar00rootroot00000000000000``Stdcompat``: compatibility module for OCaml standard library ============================================================== ``Stdcompat`` is a compatibility layer allowing programs to use some recent additions to the OCaml standard library while preserving the ability to be compiled on former versions of OCaml. The ``Stdcompat`` API is not intended to be stable, but there will be efforts to allow future versions of ``Stdcompat`` to be compiled on a large range of versions of OCaml: ``Stdcompat`` should compile (at least) on every version of OCaml from 3.08 (included). The module ``Stdcompat`` provides some definitions for values and types introduced in recent versions of the standard library. These definitions are just aliases to the matching definition of the standard library if the latter is recent enough. Otherwise, the module ``Stdcompat`` provides an alternative implementation. The signature of ``Stdcompat`` follows the signature of the standard library. All the modules are defined as sub-modules of ``Stdcompat.Stdlib``, such as ``Stdcompat.Stdlib.Pervasives``, ``Stdcompat.Stdlib.List``, etc. The module ``Stdcompat.Stdlib.Pervasives`` is included in ``Stdcompat.Stdlib``, and the module ``Stdcompat.Stdlib`` is included in ``Stdcompat`` itself. For instance, the function ``Stdcompat.really_input_string`` is an alias for ``Stdcompat.Pervasives.really_input_string``, which is an alias for ``Stdcompat.Stdlib.Pervasives.really_input_string``, which is itself an alias for ``Pervasives.really_input_string`` when the version of the OCaml compiler is above 4.02.0, or an alternative definition otherwise. The types ``Stdcompat.bytes`` and ``Stdcompat.floatarray`` are aliases to the built-in ones is the latter are available (above 4.02.0 for ``bytes`` and above 4.06.0 for ``floatarray``), and are aliases to ``string`` and ``float array`` respectively otherwise. Sub-modules match the names of the standard library modules. For instance, ``Stdcompat.List.find_opt`` is an alias for ``List.find_opt`` on 4.05.0 and above, or an alternative definition otherwise. Definitions from the standard library are reexported so that ``Stdcompat`` can be open without hiding unchanged definitions. Functors ``Set.Make``, ``Map.Make``, ``Hashtbl.Make``, ``Weak.Make`` are redefined to provide the additional definitions appeared on recent OCaml releases. If ``Pervasives.result``, ``Uchar.t`` and/or ``Seq.t`` are not provided by the standard library and if the compatibility packages ``result``, ``uchar``, and/or ``seq`` are available via ``ocamlfind``, then the types ``Stdcompat.Pervasives.result``, ``Stdcompat.Uchar.t`` and ``Stdcompat.Seq.t`` are defined as alias to the types defined in those packages (these packages should then appear before ``Stdcompat`` in the linking chain). Some redefinitions access to the internal representation of the data structures when they are abstracted: it is the case for ``{Set,Map,Hashtbl,Queue,Stack}.to_seq*``, ``Hashtbl.filter_map_inplace``, ``Hashtbl.stats``, ``Stack.fold``, ``Set.find*``, ``Set.map``. Pure (but less efficient) implementations are available by configuring ``Stdcompat`` with ``./configure --disable-magic``. Redefinitions cannot even guarantee some security fixes: for instance, seeds and randomization are ignored with ``Hashtbl`` prior to 4.00.0. See the generated documentation (in ``doc/``) for available definitions. Configure and install --------------------- Execute `make -f Makefile.bootstrap` first, to generate the files `configure`, `Makefile.in` and others. Then execute `./configure` (or `./configure --disable-magic` to use the pure and less efficient implementation). Then execute `make` and `make install`. Windows support --------------- `stdcompat` can be used on Windows, both with Cygwin and with Microsoft Visual Studio port. The build system relies on `autoconf`, `automake` and `make`, therefore the easiest way to compile `stdcompat` is to use Cygwin for compiling, with the same environment as for compiling OCaml: - `cl.exe` should be in `PATH`: for instance, with Microsoft Visual Studio 2017 Community, the `PATH` can be initialized with "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"; - `eval $(/tools/msvs-promote-path)"` should have been executed, so that the command `link.exe` points to the right tool; - moreover, `ocaml.exe`, `ocamlc.exe`, etc., should be in `PATH`. ocaml-stdcompat-20~git20240529/VERSION000066400000000000000000000000021463722102200171550ustar00rootroot0000000000000019ocaml-stdcompat-20~git20240529/ci/000077500000000000000000000000001463722102200165105ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/ci/cygwin-compile-ocaml.sh000077500000000000000000000037221463722102200230720ustar00rootroot00000000000000#!/bin/bash set -ex OCAMLVERSION="$1" URL="http://caml.inria.fr/pub/distrib/ocaml-${OCAMLVERSION:0:4}/ocaml-$OCAMLVERSION.tar.gz" if [ ! -d "/cygdrive/c/ocaml/$OCAMLVERSION/" ]; then PREFIX="C:/ocaml/$OCAMLVERSION" SOURCEDIR="ocaml-$OCAMLVERSION" if [ ! -d "$SOURCEDIR" ]; then TARBALL="ocaml-$OCAMLVERSION.tar.gz" if [ ! -f "$TARBALL" ]; then wget "$URL" fi tar --extract --file=$TARBALL fi cd "ocaml-$OCAMLVERSION" if [ `printf "$OCAMLVERSION\n4.03.0" | sort | head -n1` = 4.03.0 ]; then eval $(tools/msvs-promote-path) pushd flexdll wget https://github.com/alainfrisch/flexdll/archive/0.37.tar.gz tar --strip-components=1 --extract --file=0.37.tar.gz popd else eval $(~/ocaml-4.09.0/tools/msvs-promote-path) export PATH="$HOME/ocaml-4.09.0/flexdll:$PATH" export INCLUDE="$INCLUDE;C:/Users/ci/ocaml-4.09.0/flexdll" export OCAMLBUILD_FIND=/usr/bin/find fi if [ `printf "$OCAMLVERSION\n4.08.0" | sort | head -n1` = 4.08.0 ]; then ./configure --build=x86_64-unknown-cygwin --host=x86_64-pc-windows \ --prefix="$PREFIX" else if [ `printf "$OCAMLVERSION\n4.06.0" | sort | head -n1` = 4.06.0 ]; then cp config/m-nt.h byterun/caml/m.h cp config/s-nt.h byterun/caml/s.h else cp config/m-nt.h config/m.h cp config/s-nt.h config/s.h fi cp config/Makefile.msvc64 config/Makefile sed -i -e "s|^PREFIX=.*\$|PREFIX=$PREFIX|" config/Makefile fi if [ `printf "$OCAMLVERSION\n4.05.0" | sort | head -n1` = 4.05.0 ]; then make flexdll make world.opt make flexlink.opt make install elif [ `printf "$OCAMLVERSION\n4.03.0" | sort | head -n1` = 4.03.0 ]; then make -f Makefile.nt flexdll world bootstrap opt opt.opt install else make -f Makefile.nt world bootstrap opt opt.opt install fi fi ocaml-stdcompat-20~git20240529/compile000077500000000000000000000163501463722102200175000ustar00rootroot00000000000000#! /bin/sh # Wrapper for compilers which do not understand '-c -o'. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1999-2021 Free Software Foundation, Inc. # Written by Tom Tromey . # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # This file is maintained in Automake, please report # bugs to or send patches to # . nl=' ' # We need space, tab and new line, in precisely that order. Quoting is # there to prevent tools from complaining about whitespace usage. IFS=" "" $nl" file_conv= # func_file_conv build_file lazy # Convert a $build file to $host form and store it in $file # Currently only supports Windows hosts. If the determined conversion # type is listed in (the comma separated) LAZY, no conversion will # take place. func_file_conv () { file=$1 case $file in / | /[!/]*) # absolute file, and not a UNC file if test -z "$file_conv"; then # lazily determine how to convert abs files case `uname -s` in MINGW*) file_conv=mingw ;; CYGWIN* | MSYS*) file_conv=cygwin ;; *) file_conv=wine ;; esac fi case $file_conv/,$2, in *,$file_conv,*) ;; mingw/*) file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` ;; cygwin/* | msys/*) file=`cygpath -m "$file" || echo "$file"` ;; wine/*) file=`winepath -w "$file" || echo "$file"` ;; esac ;; esac } # func_cl_dashL linkdir # Make cl look for libraries in LINKDIR func_cl_dashL () { func_file_conv "$1" if test -z "$lib_path"; then lib_path=$file else lib_path="$lib_path;$file" fi linker_opts="$linker_opts -LIBPATH:$file" } # func_cl_dashl library # Do a library search-path lookup for cl func_cl_dashl () { lib=$1 found=no save_IFS=$IFS IFS=';' for dir in $lib_path $LIB do IFS=$save_IFS if $shared && test -f "$dir/$lib.dll.lib"; then found=yes lib=$dir/$lib.dll.lib break fi if test -f "$dir/$lib.lib"; then found=yes lib=$dir/$lib.lib break fi if test -f "$dir/lib$lib.a"; then found=yes lib=$dir/lib$lib.a break fi done IFS=$save_IFS if test "$found" != yes; then lib=$lib.lib fi } # func_cl_wrapper cl arg... # Adjust compile command to suit cl func_cl_wrapper () { # Assume a capable shell lib_path= shared=: linker_opts= for arg do if test -n "$eat"; then eat= else case $1 in -o) # configure might choose to run compile as 'compile cc -o foo foo.c'. eat=1 case $2 in *.o | *.[oO][bB][jJ]) func_file_conv "$2" set x "$@" -Fo"$file" shift ;; *) func_file_conv "$2" set x "$@" -Fe"$file" shift ;; esac ;; -I) eat=1 func_file_conv "$2" mingw set x "$@" -I"$file" shift ;; -I*) func_file_conv "${1#-I}" mingw set x "$@" -I"$file" shift ;; -l) eat=1 func_cl_dashl "$2" set x "$@" "$lib" shift ;; -l*) func_cl_dashl "${1#-l}" set x "$@" "$lib" shift ;; -L) eat=1 func_cl_dashL "$2" ;; -L*) func_cl_dashL "${1#-L}" ;; -static) shared=false ;; -Wl,*) arg=${1#-Wl,} save_ifs="$IFS"; IFS=',' for flag in $arg; do IFS="$save_ifs" linker_opts="$linker_opts $flag" done IFS="$save_ifs" ;; -Xlinker) eat=1 linker_opts="$linker_opts $2" ;; -*) set x "$@" "$1" shift ;; *.cc | *.CC | *.cxx | *.CXX | *.[cC]++) func_file_conv "$1" set x "$@" -Tp"$file" shift ;; *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO]) func_file_conv "$1" mingw set x "$@" "$file" shift ;; *) set x "$@" "$1" shift ;; esac fi shift done if test -n "$linker_opts"; then linker_opts="-link$linker_opts" fi exec "$@" $linker_opts exit 1 } eat= case $1 in '') echo "$0: No command. Try '$0 --help' for more information." 1>&2 exit 1; ;; -h | --h*) cat <<\EOF Usage: compile [--help] [--version] PROGRAM [ARGS] Wrapper for compilers which do not understand '-c -o'. Remove '-o dest.o' from ARGS, run PROGRAM with the remaining arguments, and rename the output as expected. If you are trying to build a whole package this is not the right script to run: please start by reading the file 'INSTALL'. Report bugs to . EOF exit $? ;; -v | --v*) echo "compile $scriptversion" exit $? ;; cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \ icl | *[/\\]icl | icl.exe | *[/\\]icl.exe ) func_cl_wrapper "$@" # Doesn't return... ;; esac ofile= cfile= for arg do if test -n "$eat"; then eat= else case $1 in -o) # configure might choose to run compile as 'compile cc -o foo foo.c'. # So we strip '-o arg' only if arg is an object. eat=1 case $2 in *.o | *.obj) ofile=$2 ;; *) set x "$@" -o "$2" shift ;; esac ;; *.c) cfile=$1 set x "$@" "$1" shift ;; *) set x "$@" "$1" shift ;; esac fi shift done if test -z "$ofile" || test -z "$cfile"; then # If no '-o' option was seen then we might have been invoked from a # pattern rule where we don't need one. That is ok -- this is a # normal compilation that the losing compiler can handle. If no # '.c' file was seen then we are probably linking. That is also # ok. exec "$@" fi # Name of file we expect compiler to create. cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'` # Create the lock directory. # Note: use '[/\\:.-]' here to ensure that we don't use the same name # that we are using for the .o file. Also, base the name on the expected # object file name, since that is what matters with a parallel build. lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d while true; do if mkdir "$lockdir" >/dev/null 2>&1; then break fi sleep 1 done # FIXME: race condition here if user kills between mkdir and trap. trap "rmdir '$lockdir'; exit 1" 1 2 15 # Run the compile. "$@" ret=$? if test -f "$cofile"; then test "$cofile" = "$ofile" || mv "$cofile" "$ofile" elif test -f "${cofile}bj"; then test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile" fi rmdir "$lockdir" exit $ret # Local Variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: ocaml-stdcompat-20~git20240529/config.h.in000066400000000000000000000037111463722102200201420ustar00rootroot00000000000000/* config.h.in. Generated from configure.ac by autoheader. */ /* Define if building universal (internal helper macro) */ #undef AC_APPLE_UNIVERSAL_BUILD /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDIO_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Name of package */ #undef PACKAGE /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define to 1 if all of the C89 standard headers exist (not just the ones required in a freestanding environment). This macro is provided for backward compatibility; new code need not use it. */ #undef STDC_HEADERS /* Version number of package */ #undef VERSION /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). */ #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #else # ifndef WORDS_BIGENDIAN # undef WORDS_BIGENDIAN # endif #endif ocaml-stdcompat-20~git20240529/configure000077500000000000000000010233061463722102200200310ustar00rootroot00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.72 for stdcompat 19. # # Report bugs to . # # # Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation, # Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case e in #( e) case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac ;; esac fi # Reset variables that may have inherited troublesome values from # the environment. # IFS needs to be set, to space, tab, and newline, in precisely that order. # (If _AS_PATH_WALK were called with IFS unset, it would have the # side effect of setting IFS to empty, thus disabling word splitting.) # Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl IFS=" "" $as_nl" PS1='$ ' PS2='> ' PS4='+ ' # Ensure predictable behavior from utilities with locale-dependent output. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # We cannot yet rely on "unset" to work, but we need these variables # to be unset--not just set to an empty or harmless value--now, to # avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct # also avoids known problems related to "unset" and subshell syntax # in other old shells (e.g. bash 2.01 and pdksh 5.2.14). for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH do eval test \${$as_var+y} \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done # Ensure that fds 0, 1, and 2 are open. if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as 'sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed 'exec'. printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case e in #( e) case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ) then : else case e in #( e) exitcode=1; echo positional parameters were not saved. ;; esac fi test x\$exitcode = x0 || exit 1 blah=\$(echo \$(echo blah)) test x\"\$blah\" = xblah || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1" if (eval "$as_required") 2>/dev/null then : as_have_required=yes else case e in #( e) as_have_required=no ;; esac fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null then : else case e in #( e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null then : CONFIG_SHELL=$as_shell as_have_required=yes if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null then : break 2 fi fi done;; esac as_found=false done IFS=$as_save_IFS if $as_found then : else case e in #( e) if { test -f "$SHELL" || test -f "$SHELL.exe"; } && as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null then : CONFIG_SHELL=$SHELL as_have_required=yes fi ;; esac fi if test "x$CONFIG_SHELL" != x then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed 'exec'. printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno then : printf "%s\n" "$0: This script requires a shell more modern than all" printf "%s\n" "$0: the shells that I found on your system." if test ${ZSH_VERSION+y} ; then printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should" printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later." else printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and $0: [Thierry.Martinez@inria.fr] about your system, $0: including any error possibly output before this $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." fi exit 1 fi ;; esac fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null then : eval 'as_fn_append () { eval $1+=\$2 }' else case e in #( e) as_fn_append () { eval $1=\$$1\$2 } ;; esac fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null then : eval 'as_fn_arith () { as_val=$(( $* )) }' else case e in #( e) as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } ;; esac fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' t clear :clear s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } # Determine whether it's possible to make 'echo' print without a newline. # These variables are no longer used directly by Autoconf, but are AC_SUBSTed # for compatibility with existing Makefiles. ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac # For backward compatibility with old third-party macros, we provide # the shell variables $as_echo and $as_echo_n. New code should use # AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. as_echo='printf %s\n' as_echo_n='printf %s' rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable. # In both cases, we have to default to 'cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated # Sed expression to map a string onto a valid variable name. as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g" as_tr_sh="eval sed '$as_sed_sh'" # deprecated test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='stdcompat' PACKAGE_TARNAME='stdcompat' PACKAGE_VERSION='19' PACKAGE_STRING='stdcompat 19' PACKAGE_BUGREPORT='Thierry.Martinez@inria.fr' PACKAGE_URL='https://github.com/thierry.martinez/stdcompat/' # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_STDIO_H # include #endif #ifdef HAVE_STDLIB_H # include #endif #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_header_c_list= ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS INCLUDE_DEPEND OCAML_SUPPORTS_ALERT_FALSE OCAML_SUPPORTS_ALERT_TRUE OCAML_SUPPORTS_BIN_ANNOT_FALSE OCAML_SUPPORTS_BIN_ANNOT_TRUE OCAML_SUPPORTS_NO_ALIAS_DEPS_FALSE OCAML_SUPPORTS_NO_ALIAS_DEPS_TRUE SHARED_LIBS OCAML_SUPPORTS_SHARED_FALSE OCAML_SUPPORTS_SHARED_TRUE OCAML_SUPPORTS_NATIVE_FALSE OCAML_SUPPORTS_NATIVE_TRUE OCAML_SUPPORTS_BYTECODE_FALSE OCAML_SUPPORTS_BYTECODE_TRUE C_END_WITHOUT_FLAMBDA2 C_BEGIN_WITHOUT_FLAMBDA2 END_WITHOUT_FLAMBDA2 BEGIN_WITHOUT_FLAMBDA2 C_END_WITH_FLAMBDA2 C_BEGIN_WITH_FLAMBDA2 END_WITH_FLAMBDA2 BEGIN_WITH_FLAMBDA2 C_END_WITHOUT_UNIX C_BEGIN_WITHOUT_UNIX END_WITHOUT_UNIX BEGIN_WITHOUT_UNIX C_END_WITH_UNIX C_BEGIN_WITH_UNIX END_WITH_UNIX BEGIN_WITH_UNIX C_END_WITHOUT_CYGWIN C_BEGIN_WITHOUT_CYGWIN END_WITHOUT_CYGWIN BEGIN_WITHOUT_CYGWIN C_END_WITH_CYGWIN C_BEGIN_WITH_CYGWIN END_WITH_CYGWIN BEGIN_WITH_CYGWIN C_END_WITHOUT_WIN32 C_BEGIN_WITHOUT_WIN32 END_WITHOUT_WIN32 BEGIN_WITHOUT_WIN32 C_END_WITH_WIN32 C_BEGIN_WITH_WIN32 END_WITH_WIN32 BEGIN_WITH_WIN32 C_END_BEFORE_5_2_0 C_BEGIN_BEFORE_5_2_0 END_BEFORE_5_2_0 BEGIN_BEFORE_5_2_0 C_END_FROM_5_2_0 C_BEGIN_FROM_5_2_0 END_FROM_5_2_0 BEGIN_FROM_5_2_0 C_END_BEFORE_5_1_0 C_BEGIN_BEFORE_5_1_0 END_BEFORE_5_1_0 BEGIN_BEFORE_5_1_0 C_END_FROM_5_1_0 C_BEGIN_FROM_5_1_0 END_FROM_5_1_0 BEGIN_FROM_5_1_0 C_END_BEFORE_5_0_0 C_BEGIN_BEFORE_5_0_0 END_BEFORE_5_0_0 BEGIN_BEFORE_5_0_0 C_END_FROM_5_0_0 C_BEGIN_FROM_5_0_0 END_FROM_5_0_0 BEGIN_FROM_5_0_0 C_END_BEFORE_4_14_0 C_BEGIN_BEFORE_4_14_0 END_BEFORE_4_14_0 BEGIN_BEFORE_4_14_0 C_END_FROM_4_14_0 C_BEGIN_FROM_4_14_0 END_FROM_4_14_0 BEGIN_FROM_4_14_0 C_END_BEFORE_4_13_0 C_BEGIN_BEFORE_4_13_0 END_BEFORE_4_13_0 BEGIN_BEFORE_4_13_0 C_END_FROM_4_13_0 C_BEGIN_FROM_4_13_0 END_FROM_4_13_0 BEGIN_FROM_4_13_0 C_END_BEFORE_4_12_0 C_BEGIN_BEFORE_4_12_0 END_BEFORE_4_12_0 BEGIN_BEFORE_4_12_0 C_END_FROM_4_12_0 C_BEGIN_FROM_4_12_0 END_FROM_4_12_0 BEGIN_FROM_4_12_0 C_END_BEFORE_4_11_0 C_BEGIN_BEFORE_4_11_0 END_BEFORE_4_11_0 BEGIN_BEFORE_4_11_0 C_END_FROM_4_11_0 C_BEGIN_FROM_4_11_0 END_FROM_4_11_0 BEGIN_FROM_4_11_0 C_END_BEFORE_4_10_0 C_BEGIN_BEFORE_4_10_0 END_BEFORE_4_10_0 BEGIN_BEFORE_4_10_0 C_END_FROM_4_10_0 C_BEGIN_FROM_4_10_0 END_FROM_4_10_0 BEGIN_FROM_4_10_0 C_END_BEFORE_4_09_0 C_BEGIN_BEFORE_4_09_0 END_BEFORE_4_09_0 BEGIN_BEFORE_4_09_0 C_END_FROM_4_09_0 C_BEGIN_FROM_4_09_0 END_FROM_4_09_0 BEGIN_FROM_4_09_0 C_END_BEFORE_4_08_0 C_BEGIN_BEFORE_4_08_0 END_BEFORE_4_08_0 BEGIN_BEFORE_4_08_0 C_END_FROM_4_08_0 C_BEGIN_FROM_4_08_0 END_FROM_4_08_0 BEGIN_FROM_4_08_0 C_END_BEFORE_4_07_1 C_BEGIN_BEFORE_4_07_1 END_BEFORE_4_07_1 BEGIN_BEFORE_4_07_1 C_END_FROM_4_07_1 C_BEGIN_FROM_4_07_1 END_FROM_4_07_1 BEGIN_FROM_4_07_1 C_END_BEFORE_4_07_0 C_BEGIN_BEFORE_4_07_0 END_BEFORE_4_07_0 BEGIN_BEFORE_4_07_0 C_END_FROM_4_07_0 C_BEGIN_FROM_4_07_0 END_FROM_4_07_0 BEGIN_FROM_4_07_0 C_END_BEFORE_4_06_0 C_BEGIN_BEFORE_4_06_0 END_BEFORE_4_06_0 BEGIN_BEFORE_4_06_0 C_END_FROM_4_06_0 C_BEGIN_FROM_4_06_0 END_FROM_4_06_0 BEGIN_FROM_4_06_0 C_END_BEFORE_4_05_0 C_BEGIN_BEFORE_4_05_0 END_BEFORE_4_05_0 BEGIN_BEFORE_4_05_0 C_END_FROM_4_05_0 C_BEGIN_FROM_4_05_0 END_FROM_4_05_0 BEGIN_FROM_4_05_0 C_END_BEFORE_4_04_0 C_BEGIN_BEFORE_4_04_0 END_BEFORE_4_04_0 BEGIN_BEFORE_4_04_0 C_END_FROM_4_04_0 C_BEGIN_FROM_4_04_0 END_FROM_4_04_0 BEGIN_FROM_4_04_0 C_END_BEFORE_4_03_0 C_BEGIN_BEFORE_4_03_0 END_BEFORE_4_03_0 BEGIN_BEFORE_4_03_0 C_END_FROM_4_03_0 C_BEGIN_FROM_4_03_0 END_FROM_4_03_0 BEGIN_FROM_4_03_0 C_END_BEFORE_4_02_0 C_BEGIN_BEFORE_4_02_0 END_BEFORE_4_02_0 BEGIN_BEFORE_4_02_0 C_END_FROM_4_02_0 C_BEGIN_FROM_4_02_0 END_FROM_4_02_0 BEGIN_FROM_4_02_0 C_END_BEFORE_4_01_0 C_BEGIN_BEFORE_4_01_0 END_BEFORE_4_01_0 BEGIN_BEFORE_4_01_0 C_END_FROM_4_01_0 C_BEGIN_FROM_4_01_0 END_FROM_4_01_0 BEGIN_FROM_4_01_0 C_END_BEFORE_4_00_0 C_BEGIN_BEFORE_4_00_0 END_BEFORE_4_00_0 BEGIN_BEFORE_4_00_0 C_END_FROM_4_00_0 C_BEGIN_FROM_4_00_0 END_FROM_4_00_0 BEGIN_FROM_4_00_0 C_END_BEFORE_3_12_0 C_BEGIN_BEFORE_3_12_0 END_BEFORE_3_12_0 BEGIN_BEFORE_3_12_0 C_END_FROM_3_12_0 C_BEGIN_FROM_3_12_0 END_FROM_3_12_0 BEGIN_FROM_3_12_0 C_END_BEFORE_3_11_0 C_BEGIN_BEFORE_3_11_0 END_BEFORE_3_11_0 BEGIN_BEFORE_3_11_0 C_END_FROM_3_11_0 C_BEGIN_FROM_3_11_0 END_FROM_3_11_0 BEGIN_FROM_3_11_0 C_END_BEFORE_3_10_0 C_BEGIN_BEFORE_3_10_0 END_BEFORE_3_10_0 BEGIN_BEFORE_3_10_0 C_END_FROM_3_10_0 C_BEGIN_FROM_3_10_0 END_FROM_3_10_0 BEGIN_FROM_3_10_0 C_END_BEFORE_3_09_0 C_BEGIN_BEFORE_3_09_0 END_BEFORE_3_09_0 BEGIN_BEFORE_3_09_0 C_END_FROM_3_09_0 C_BEGIN_FROM_3_09_0 END_FROM_3_09_0 BEGIN_FROM_3_09_0 C_END_BEFORE_3_08_0 C_BEGIN_BEFORE_3_08_0 END_BEFORE_3_08_0 BEGIN_BEFORE_3_08_0 C_END_FROM_3_08_0 C_BEGIN_FROM_3_08_0 END_FROM_3_08_0 BEGIN_FROM_3_08_0 C_END_BEFORE_3_07_0 C_BEGIN_BEFORE_3_07_0 END_BEFORE_3_07_0 BEGIN_BEFORE_3_07_0 C_END_FROM_3_07_0 C_BEGIN_FROM_3_07_0 END_FROM_3_07_0 BEGIN_FROM_3_07_0 C_END_WITHOUT_UCHAR_PKG C_BEGIN_WITHOUT_UCHAR_PKG END_WITHOUT_UCHAR_PKG BEGIN_WITHOUT_UCHAR_PKG C_END_WITH_UCHAR_PKG C_BEGIN_WITH_UCHAR_PKG END_WITH_UCHAR_PKG BEGIN_WITH_UCHAR_PKG C_END_WITHOUT_SEQ_PKG C_BEGIN_WITHOUT_SEQ_PKG END_WITHOUT_SEQ_PKG BEGIN_WITHOUT_SEQ_PKG C_END_WITH_SEQ_PKG C_BEGIN_WITH_SEQ_PKG END_WITH_SEQ_PKG BEGIN_WITH_SEQ_PKG C_END_WITHOUT_RESULT_PKG C_BEGIN_WITHOUT_RESULT_PKG END_WITHOUT_RESULT_PKG BEGIN_WITHOUT_RESULT_PKG C_END_WITH_RESULT_PKG C_BEGIN_WITH_RESULT_PKG END_WITH_RESULT_PKG BEGIN_WITH_RESULT_PKG C_END_WITHOUT_MAGIC C_BEGIN_WITHOUT_MAGIC END_WITHOUT_MAGIC BEGIN_WITHOUT_MAGIC C_END_WITH_MAGIC C_BEGIN_WITH_MAGIC END_WITH_MAGIC BEGIN_WITH_MAGIC enable_magic OCAML_FLAMBDA2 target_os_type BIG_ENDIAN am__fastdepCC_FALSE am__fastdepCC_TRUE CCDEPMODE am__nodep AMDEPBACKSLASH AMDEP_FALSE AMDEP_TRUE am__include DEPDIR OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC CMAX OCAMLBEST UCHAR_PKG SEQ_PKG RESULT_PKG OCAMLMKLIB OCAMLDEP OCAMLDOC OCAMLOPT OCAMLFIND OCAML_DEVELOPMENT_VERSION OCAML_RELEASE_EXTRA_PREFIX OCAML_RELEASE_EXTRA OCAML_RELEASE_EXTRA_PREFIX_CHAR OCAML_VERSION_PATCHLEVEL OCAML_VERSION_PATCH_AND_EXTRA OCAML_VERSION_MINOR OCAML_VERSION_MAJOR OCAMLVERSION OCAMLC OCAML MAINT MAINTAINER_MODE_FALSE MAINTAINER_MODE_TRUE AM_BACKSLASH AM_DEFAULT_VERBOSITY AM_DEFAULT_V AM_V CSCOPE ETAGS CTAGS am__untar am__tar AMTAR am__leading_dot SET_MAKE AWK mkdir_p MKDIR_P INSTALL_STRIP_PROGRAM STRIP install_sh MAKEINFO AUTOHEADER AUTOMAKE AUTOCONF ACLOCAL VERSION PACKAGE CYGPATH_W am__isrc INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir runstatedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL am__quote' ac_subst_files='' ac_user_opts=' enable_option_checking enable_silent_rules enable_maintainer_mode enable_dependency_tracking enable_magic ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' runstatedir='${localstatedir}/run' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -runstatedir | --runstatedir | --runstatedi | --runstated \ | --runstate | --runstat | --runsta | --runst | --runs \ | --run | --ru | --r) ac_prev=runstatedir ;; -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ | --run=* | --ru=* | --r=*) runstatedir=$ac_optarg ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: '$ac_option' Try '$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: '$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir runstatedir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: '$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but 'cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF 'configure' configures stdcompat 19 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print 'checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for '--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or '..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, 'make install' will install all the files in '$ac_default_prefix/bin', '$ac_default_prefix/lib' etc. You can specify an installation prefix other than '$ac_default_prefix' using '--prefix', for instance '--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/stdcompat] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF Program names: --program-prefix=PREFIX prepend PREFIX to installed program names --program-suffix=SUFFIX append SUFFIX to installed program names --program-transform-name=PROGRAM run sed PROGRAM on installed program names _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of stdcompat 19:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --enable-silent-rules less verbose build output (undo: "make V=1") --disable-silent-rules verbose build output (undo: "make V=0") --enable-maintainer-mode enable make rules and dependencies not useful (and sometimes confusing) to the casual installer --enable-dependency-tracking do not reject slow dependency extractors --disable-dependency-tracking speeds up one-time build --enable-magic [use Obj.magic in redefinitions when possible (default)], --disable-magic [use only pure redefinitions (without Obj.magic)] Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory Use these variables to override the choices made by 'configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . stdcompat home page: . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for configure.gnu first; this name is used for a wrapper for # Metaconfig's "Configure" on case-insensitive file systems. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF stdcompat configure 19 generated by GNU Autoconf 2.72 Copyright (C) 2023 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest.beam if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext then : ac_retval=0 else case e in #( e) printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; esac fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext } then : ac_retval=0 else case e in #( e) printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; esac fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_try_run LINENO # ---------------------- # Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that # executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } then : ac_retval=0 else case e in #( e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5 printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status ;; esac fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 else case e in #( e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO" then : eval "$3=yes" else case e in #( e) eval "$3=no" ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 printf "%s\n" "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile ac_configure_args_raw= for ac_arg do case $ac_arg in *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append ac_configure_args_raw " '$ac_arg'" done case $ac_configure_args_raw in *$as_nl*) ac_safe_unquote= ;; *) ac_unsafe_z='|&;<>()$`\\"*?[ '' ' # This string ends in space, tab. ac_unsafe_a="$ac_unsafe_z#~" ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g" ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; esac cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by stdcompat $as_me 19, which was generated by GNU Autoconf 2.72. Invocation command line was $ $0$ac_configure_args_raw _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac printf "%s\n" "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Sanitize IFS. IFS=" "" $as_nl" # Save into config.log some information that might help in debugging. { echo printf "%s\n" "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo printf "%s\n" "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then printf "%s\n" "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then printf "%s\n" "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && printf "%s\n" "$as_me: caught signal $ac_signal" printf "%s\n" "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h printf "%s\n" "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. if test -n "$CONFIG_SITE"; then ac_site_files="$CONFIG_SITE" elif test "x$prefix" != xNONE; then ac_site_files="$prefix/share/config.site $prefix/etc/config.site" else ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi for ac_site_file in $ac_site_files do case $ac_site_file in #( */*) : ;; #( *) : ac_site_file=./$ac_site_file ;; esac if test -f "$ac_site_file" && test -r "$ac_site_file"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See 'config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 printf "%s\n" "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 printf "%s\n" "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Test code for whether the C compiler supports C89 (global declarations) ac_c_conftest_c89_globals=' /* Does the compiler advertise C89 conformance? Do not test the value of __STDC__, because some compilers set it to 0 while being otherwise adequately conformant. */ #if !defined __STDC__ # error "Compiler does not advertise C89 conformance" #endif #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */ struct buf { int x; }; struct buf * (*rcsopen) (struct buf *, struct stat *, int); static char *e (char **p, int i) { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* C89 style stringification. */ #define noexpand_stringify(a) #a const char *stringified = noexpand_stringify(arbitrary+token=sequence); /* C89 style token pasting. Exercises some of the corner cases that e.g. old MSVC gets wrong, but not very hard. */ #define noexpand_concat(a,b) a##b #define expand_concat(a,b) noexpand_concat(a,b) extern int vA; extern int vbee; #define aye A #define bee B int *pvA = &expand_concat(v,aye); int *pvbee = &noexpand_concat(v,bee); /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not \xHH hex character constants. These do not provoke an error unfortunately, instead are silently treated as an "x". The following induces an error, until -std is added to get proper ANSI mode. Curiously \x00 != x always comes out true, for an array size at least. It is necessary to write \x00 == 0 to get something that is true only with -std. */ int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) '\''x'\'' int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int), int, int);' # Test code for whether the C compiler supports C89 (body of main). ac_c_conftest_c89_main=' ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]); ' # Test code for whether the C compiler supports C99 (global declarations) ac_c_conftest_c99_globals=' /* Does the compiler advertise C99 conformance? */ #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L # error "Compiler does not advertise C99 conformance" #endif // See if C++-style comments work. #include extern int puts (const char *); extern int printf (const char *, ...); extern int dprintf (int, const char *, ...); extern void *malloc (size_t); extern void free (void *); // Check varargs macros. These examples are taken from C99 6.10.3.5. // dprintf is used instead of fprintf to avoid needing to declare // FILE and stderr. #define debug(...) dprintf (2, __VA_ARGS__) #define showlist(...) puts (#__VA_ARGS__) #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) static void test_varargs_macros (void) { int x = 1234; int y = 5678; debug ("Flag"); debug ("X = %d\n", x); showlist (The first, second, and third items.); report (x>y, "x is %d but y is %d", x, y); } // Check long long types. #define BIG64 18446744073709551615ull #define BIG32 4294967295ul #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) #if !BIG_OK #error "your preprocessor is broken" #endif #if BIG_OK #else #error "your preprocessor is broken" #endif static long long int bignum = -9223372036854775807LL; static unsigned long long int ubignum = BIG64; struct incomplete_array { int datasize; double data[]; }; struct named_init { int number; const wchar_t *name; double average; }; typedef const char *ccp; static inline int test_restrict (ccp restrict text) { // Iterate through items via the restricted pointer. // Also check for declarations in for loops. for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i) continue; return 0; } // Check varargs and va_copy. static bool test_varargs (const char *format, ...) { va_list args; va_start (args, format); va_list args_copy; va_copy (args_copy, args); const char *str = ""; int number = 0; float fnumber = 0; while (*format) { switch (*format++) { case '\''s'\'': // string str = va_arg (args_copy, const char *); break; case '\''d'\'': // int number = va_arg (args_copy, int); break; case '\''f'\'': // float fnumber = va_arg (args_copy, double); break; default: break; } } va_end (args_copy); va_end (args); return *str && number && fnumber; } ' # Test code for whether the C compiler supports C99 (body of main). ac_c_conftest_c99_main=' // Check bool. _Bool success = false; success |= (argc != 0); // Check restrict. if (test_restrict ("String literal") == 0) success = true; char *restrict newvar = "Another string"; // Check varargs. success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234); test_varargs_macros (); // Check flexible array members. struct incomplete_array *ia = malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; // Work around memory leak warnings. free (ia); // Check named initializers. struct named_init ni = { .number = 34, .name = L"Test wide string", .average = 543.34343, }; ni.number = 58; int dynamic_array[ni.number]; dynamic_array[0] = argv[0][0]; dynamic_array[ni.number - 1] = 543; // work around unused variable warnings ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' || dynamic_array[ni.number - 1] != 543); ' # Test code for whether the C compiler supports C11 (global declarations) ac_c_conftest_c11_globals=' /* Does the compiler advertise C11 conformance? */ #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L # error "Compiler does not advertise C11 conformance" #endif // Check _Alignas. char _Alignas (double) aligned_as_double; char _Alignas (0) no_special_alignment; extern char aligned_as_int; char _Alignas (0) _Alignas (int) aligned_as_int; // Check _Alignof. enum { int_alignment = _Alignof (int), int_array_alignment = _Alignof (int[100]), char_alignment = _Alignof (char) }; _Static_assert (0 < -_Alignof (int), "_Alignof is signed"); // Check _Noreturn. int _Noreturn does_not_return (void) { for (;;) continue; } // Check _Static_assert. struct test_static_assert { int x; _Static_assert (sizeof (int) <= sizeof (long int), "_Static_assert does not work in struct"); long int y; }; // Check UTF-8 literals. #define u8 syntax error! char const utf8_literal[] = u8"happens to be ASCII" "another string"; // Check duplicate typedefs. typedef long *long_ptr; typedef long int *long_ptr; typedef long_ptr long_ptr; // Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. struct anonymous { union { struct { int i; int j; }; struct { int k; long int l; } w; }; int m; } v1; ' # Test code for whether the C compiler supports C11 (body of main). ac_c_conftest_c11_main=' _Static_assert ((offsetof (struct anonymous, i) == offsetof (struct anonymous, w.k)), "Anonymous union alignment botch"); v1.i = 2; v1.w.k = 5; ok |= v1.i != 5; ' # Test code for whether the C compiler supports C11 (complete). ac_c_conftest_c11_program="${ac_c_conftest_c89_globals} ${ac_c_conftest_c99_globals} ${ac_c_conftest_c11_globals} int main (int argc, char **argv) { int ok = 0; ${ac_c_conftest_c89_main} ${ac_c_conftest_c99_main} ${ac_c_conftest_c11_main} return ok; } " # Test code for whether the C compiler supports C99 (complete). ac_c_conftest_c99_program="${ac_c_conftest_c89_globals} ${ac_c_conftest_c99_globals} int main (int argc, char **argv) { int ok = 0; ${ac_c_conftest_c89_main} ${ac_c_conftest_c99_main} return ok; } " # Test code for whether the C compiler supports C89 (complete). ac_c_conftest_c89_program="${ac_c_conftest_c89_globals} int main (int argc, char **argv) { int ok = 0; ${ac_c_conftest_c89_main} return ok; } " as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H" as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H" as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H" as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H" as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H" as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H" as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H" as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H" as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H" # Auxiliary files required by this configure script. ac_aux_files="compile missing install-sh" # Locations in which to look for auxiliary files. ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.." # Search for a directory containing all of the required auxiliary files, # $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates. # If we don't find one directory that contains all the files we need, # we report the set of missing files from the *first* directory in # $ac_aux_dir_candidates and give up. ac_missing_aux_files="" ac_first_candidate=: printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in $ac_aux_dir_candidates do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac as_found=: printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 ac_aux_dir_found=yes ac_install_sh= for ac_aux in $ac_aux_files do # As a special case, if "install-sh" is required, that requirement # can be satisfied by any of "install-sh", "install.sh", or "shtool", # and $ac_install_sh is set appropriately for whichever one is found. if test x"$ac_aux" = x"install-sh" then if test -f "${as_dir}install-sh"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 ac_install_sh="${as_dir}install-sh -c" elif test -f "${as_dir}install.sh"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 ac_install_sh="${as_dir}install.sh -c" elif test -f "${as_dir}shtool"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 ac_install_sh="${as_dir}shtool install -c" else ac_aux_dir_found=no if $ac_first_candidate; then ac_missing_aux_files="${ac_missing_aux_files} install-sh" else break fi fi else if test -f "${as_dir}${ac_aux}"; then printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 else ac_aux_dir_found=no if $ac_first_candidate; then ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}" else break fi fi fi done if test "$ac_aux_dir_found" = yes; then ac_aux_dir="$as_dir" break fi ac_first_candidate=false as_found=false done IFS=$as_save_IFS if $as_found then : else case e in #( e) as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 ;; esac fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. if test -f "${ac_aux_dir}config.guess"; then ac_config_guess="$SHELL ${ac_aux_dir}config.guess" fi if test -f "${ac_aux_dir}config.sub"; then ac_config_sub="$SHELL ${ac_aux_dir}config.sub" fi if test -f "$ac_aux_dir/configure"; then ac_configure="$SHELL ${ac_aux_dir}configure" fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5 printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5 printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5 printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5 printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5 printf "%s\n" "$as_me: former value: '$ac_old_val'" >&2;} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5 printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu am__api_version='1.16' # Find a good install program. We prefer a C program (faster), # so one script is as good as another. But avoid the broken or # incompatible versions: # SysV /etc/install, /usr/sbin/install # SunOS /usr/etc/install # IRIX /sbin/install # AIX /bin/install # AmigaOS /C/install, which installs bootblocks on floppy discs # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # OS/2's system install, which has a completely different semantic # ./install, which can be erroneously created by make from ./install.sh. # Reject install programs that cannot install multiple files. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 printf %s "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then if test ${ac_cv_path_install+y} then : printf %s "(cached) " >&6 else case e in #( e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac # Account for fact that we put trailing slashes in our PATH walk. case $as_dir in #(( ./ | /[cC]/* | \ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ /usr/ucb/* ) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. # Don't use installbsd from OSF since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext"; then if test $ac_prog = install && grep dspmsg "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. : elif test $ac_prog = install && grep pwplus "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # program-specific install script used by HP pwplus--don't use. : else rm -rf conftest.one conftest.two conftest.dir echo one > conftest.one echo two > conftest.two mkdir conftest.dir if "$as_dir$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir/" && test -s conftest.one && test -s conftest.two && test -s conftest.dir/conftest.one && test -s conftest.dir/conftest.two then ac_cv_path_install="$as_dir$ac_prog$ac_exec_ext -c" break 3 fi fi fi done done ;; esac done IFS=$as_save_IFS rm -rf conftest.one conftest.two conftest.dir ;; esac fi if test ${ac_cv_path_install+y}; then INSTALL=$ac_cv_path_install else # As a last resort, use the slow shell script. Don't cache a # value for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. INSTALL=$ac_install_sh fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 printf "%s\n" "$INSTALL" >&6; } # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 printf %s "checking whether build environment is sane... " >&6; } # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[\\\"\#\$\&\'\`$am_lf]*) as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; esac case $srcdir in *[\\\"\#\$\&\'\`$am_lf\ \ ]*) as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; esac # Do 'set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( am_has_slept=no for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$*" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi if test "$*" != "X $srcdir/configure conftest.file" \ && test "$*" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". as_fn_error $? "ls -t appears to fail. Make sure there is not a broken alias in your environment" "$LINENO" 5 fi if test "$2" = conftest.file || test $am_try -eq 2; then break fi # Just in case. sleep 1 am_has_slept=yes done test "$2" = conftest.file ) then # Ok. : else as_fn_error $? "newly created file is older than distributed files! Check your system clock" "$LINENO" 5 fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } # If we didn't sleep, we still need to ensure time stamps of config.status and # generated files are strictly newer. am_sleep_pid= if grep 'slept: no' conftest.file >/dev/null 2>&1; then ( sleep 1 ) & am_sleep_pid=$! fi rm -f conftest.file test "$program_prefix" != NONE && program_transform_name="s&^&$program_prefix&;$program_transform_name" # Use a double $ so make ignores it. test "$program_suffix" != NONE && program_transform_name="s&\$&$program_suffix&;$program_transform_name" # Double any \ or $. # By default was 's,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"` # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` if test x"${MISSING+set}" != xset; then MISSING="\${SHELL} '$am_aux_dir/missing'" fi # Use eval to expand $SHELL if eval "$MISSING --is-lightweight"; then am_missing_run="$MISSING " else am_missing_run= { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;} fi if test x"${install_sh+set}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi # Installed binaries are usually stripped using 'strip' when the user # run "make install-strip". However 'strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the 'STRIP' environment variable to overrule this program. if test "$cross_compiling" != no; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 printf "%s\n" "$STRIP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 printf "%s\n" "$ac_ct_STRIP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then STRIP=":" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP="$ac_cv_prog_STRIP" fi fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5 printf %s "checking for a race-free mkdir -p... " >&6; } if test -z "$MKDIR_P"; then if test ${ac_cv_path_mkdir+y} then : printf %s "(cached) " >&6 else case e in #( e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_prog in mkdir gmkdir; do for ac_exec_ext in '' $ac_executable_extensions; do as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #( 'mkdir ('*'coreutils) '* | \ *'BusyBox '* | \ 'mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext break 3;; esac done done done IFS=$as_save_IFS ;; esac fi test -d ./--version && rmdir ./--version if test ${ac_cv_path_mkdir+y}; then MKDIR_P="$ac_cv_path_mkdir -p" else # As a last resort, use plain mkdir -p, # in the hope it doesn't have the bugs of ancient mkdir. MKDIR_P='mkdir -p' fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 printf "%s\n" "$MKDIR_P" >&6; } for ac_prog in gawk mawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AWK+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 printf "%s\n" "$AWK" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi test -n "$AWK" && break done { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval test \${ac_cv_prog_make_${ac_make}_set+y} then : printf %s "(cached) " >&6 else case e in #( e) cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make ;; esac fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } SET_MAKE= else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null # Check whether --enable-silent-rules was given. if test ${enable_silent_rules+y} then : enableval=$enable_silent_rules; fi case $enable_silent_rules in # ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; *) AM_DEFAULT_VERBOSITY=1;; esac am_make=${MAKE-make} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 printf %s "checking whether $am_make supports nested variables... " >&6; } if test ${am_cv_make_support_nested_variables+y} then : printf %s "(cached) " >&6 else case e in #( e) if printf "%s\n" 'TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 am__doit: @$(TRUE) .PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no fi ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 printf "%s\n" "$am_cv_make_support_nested_variables" >&6; } if test $am_cv_make_support_nested_variables = yes; then AM_V='$(V)' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi AM_BACKSLASH='\' if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." am__isrc=' -I$(srcdir)' # test to see if srcdir already configured if test -f $srcdir/config.status; then as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi # Define the identity of the package. PACKAGE='stdcompat' VERSION='19' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h printf "%s\n" "#define VERSION \"$VERSION\"" >>confdefs.h # Some tools Automake needs. ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} # For better backward compatibility. To be removed once Automake 1.9.x # dies out for good. For more background, see: # # mkdir_p='$(MKDIR_P)' # We need awk for the "check" target (and possibly the TAP driver). The # system "awk" is bad on some platforms. # Always define AMTAR for backward compatibility. Yes, it's still used # in the wild :-( We should find a proper way to deprecate it ... AMTAR='$${TAR-tar}' # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar pax cpio none' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' # Variables for tags utilities; see am/tags.am if test -z "$CTAGS"; then CTAGS=ctags fi if test -z "$ETAGS"; then ETAGS=etags fi if test -z "$CSCOPE"; then CSCOPE=cscope fi # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5 fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5 printf %s "checking whether to enable maintainer-specific portions of Makefiles... " >&6; } # Check whether --enable-maintainer-mode was given. if test ${enable_maintainer_mode+y} then : enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval else case e in #( e) USE_MAINTAINER_MODE=no ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5 printf "%s\n" "$USE_MAINTAINER_MODE" >&6; } if test $USE_MAINTAINER_MODE = yes; then MAINTAINER_MODE_TRUE= MAINTAINER_MODE_FALSE='#' else MAINTAINER_MODE_TRUE='#' MAINTAINER_MODE_FALSE= fi MAINT=$MAINTAINER_MODE_TRUE if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocaml", so it can be a program name with args. set dummy ${ac_tool_prefix}ocaml; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAML+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAML"; then ac_cv_prog_OCAML="$OCAML" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAML="${ac_tool_prefix}ocaml" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAML=$ac_cv_prog_OCAML if test -n "$OCAML"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAML" >&5 printf "%s\n" "$OCAML" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAML"; then ac_ct_OCAML=$OCAML # Extract the first word of "ocaml", so it can be a program name with args. set dummy ocaml; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAML+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAML"; then ac_cv_prog_ac_ct_OCAML="$ac_ct_OCAML" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAML="ocaml" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAML=$ac_cv_prog_ac_ct_OCAML if test -n "$ac_ct_OCAML"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAML" >&5 printf "%s\n" "$ac_ct_OCAML" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAML" = x; then OCAML="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAML=$ac_ct_OCAML fi else OCAML="$ac_cv_prog_OCAML" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlc.opt", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlc.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLC"; then ac_cv_prog_OCAMLC="$OCAMLC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLC="${ac_tool_prefix}ocamlc.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLC=$ac_cv_prog_OCAMLC if test -n "$OCAMLC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLC" >&5 printf "%s\n" "$OCAMLC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLC"; then ac_ct_OCAMLC=$OCAMLC # Extract the first word of "ocamlc.opt", so it can be a program name with args. set dummy ocamlc.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLC"; then ac_cv_prog_ac_ct_OCAMLC="$ac_ct_OCAMLC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLC="ocamlc.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLC=$ac_cv_prog_ac_ct_OCAMLC if test -n "$ac_ct_OCAMLC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLC" >&5 printf "%s\n" "$ac_ct_OCAMLC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLC" = x; then OCAMLC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLC=$ac_ct_OCAMLC fi else OCAMLC="$ac_cv_prog_OCAMLC" fi if test "x$OCAMLC" = "x" then : if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlc", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLC"; then ac_cv_prog_OCAMLC="$OCAMLC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLC="${ac_tool_prefix}ocamlc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLC=$ac_cv_prog_OCAMLC if test -n "$OCAMLC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLC" >&5 printf "%s\n" "$OCAMLC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLC"; then ac_ct_OCAMLC=$OCAMLC # Extract the first word of "ocamlc", so it can be a program name with args. set dummy ocamlc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLC"; then ac_cv_prog_ac_ct_OCAMLC="$ac_ct_OCAMLC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLC="ocamlc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLC=$ac_cv_prog_ac_ct_OCAMLC if test -n "$ac_ct_OCAMLC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLC" >&5 printf "%s\n" "$ac_ct_OCAMLC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLC" = x; then OCAMLC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLC=$ac_ct_OCAMLC fi else OCAMLC="$ac_cv_prog_OCAMLC" fi fi # ocamlc --version is not supported by OCaml <4.03 # \($\|\r\) is not supported by Mac OS sed { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking OCaml version" >&5 printf %s "checking OCaml version... " >&6; } OCAMLVERSION=`$OCAMLC -v | sed -n 's/^.*version \(.*\)$/\1/p' | sed 's/\r//'` { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLVERSION" >&5 printf "%s\n" "$OCAMLVERSION" >&6; } OCAML_VERSION_MAJOR=`echo $OCAMLVERSION | cut -d '.' -f 1` OCAML_VERSION_MINOR=`echo $OCAMLVERSION | cut -d '.' -f 2` OCAML_VERSION_PATCH_AND_EXTRA=`echo $OCAMLVERSION | cut -d '.' -f 3` if test "x$OCAML_VERSION_PATCH_AND_EXTRA" = "x" then : OCAML_VERSION_PATCHLEVEL=0 OCAML_RELEASE_EXTRA_PREFIX_CHAR= else case e in #( e) OCAML_VERSION_PATCHLEVEL=`echo $OCAML_VERSION_PATCH_AND_EXTRA | cut -c 1` OCAML_RELEASE_EXTRA_PREFIX_CHAR=`echo $OCAML_VERSION_PATCH_AND_EXTRA | cut -c 2` ;; esac fi if test "x$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "x" then : OCAML_RELEASE_EXTRA=None else case e in #( e) if test "$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "+" then : OCAML_RELEASE_EXTRA_PREFIX=Plus else case e in #( e) OCAML_RELEASE_EXTRA_PREFIX=Tilde ;; esac fi OCAML_RELEASE_EXTRA="Some ($OCAML_RELEASE_EXTRA_PREFIX, \"`echo $OCAML_VERSION_PATCH_AND_EXTRA | cut -c 3-`\")" ;; esac fi if test "$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "~" then : OCAML_DEVELOPMENT_VERSION=true else case e in #( e) if test "$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "+" then : if echo $OCAMLVERSION | grep trunk then : OCAML_DEVELOPMENT_VERSION=true else case e in #( e) OCAML_DEVELOPMENT_VERSION=false ;; esac fi else case e in #( e) OCAML_DEVELOPMENT_VERSION=false ;; esac fi ;; esac fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlfind", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlfind; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLFIND+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLFIND"; then ac_cv_prog_OCAMLFIND="$OCAMLFIND" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLFIND="${ac_tool_prefix}ocamlfind" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLFIND=$ac_cv_prog_OCAMLFIND if test -n "$OCAMLFIND"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLFIND" >&5 printf "%s\n" "$OCAMLFIND" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLFIND"; then ac_ct_OCAMLFIND=$OCAMLFIND # Extract the first word of "ocamlfind", so it can be a program name with args. set dummy ocamlfind; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLFIND+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLFIND"; then ac_cv_prog_ac_ct_OCAMLFIND="$ac_ct_OCAMLFIND" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLFIND="ocamlfind" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLFIND=$ac_cv_prog_ac_ct_OCAMLFIND if test -n "$ac_ct_OCAMLFIND"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLFIND" >&5 printf "%s\n" "$ac_ct_OCAMLFIND" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLFIND" = x; then OCAMLFIND="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLFIND=$ac_ct_OCAMLFIND fi else OCAMLFIND="$ac_cv_prog_OCAMLFIND" fi if test "x$OCAMLFIND" = "x" then : if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlopt.opt", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlopt.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLOPT+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLOPT"; then ac_cv_prog_OCAMLOPT="$OCAMLOPT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLOPT="${ac_tool_prefix}ocamlopt.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLOPT=$ac_cv_prog_OCAMLOPT if test -n "$OCAMLOPT"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLOPT" >&5 printf "%s\n" "$OCAMLOPT" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLOPT"; then ac_ct_OCAMLOPT=$OCAMLOPT # Extract the first word of "ocamlopt.opt", so it can be a program name with args. set dummy ocamlopt.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLOPT+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLOPT"; then ac_cv_prog_ac_ct_OCAMLOPT="$ac_ct_OCAMLOPT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLOPT="ocamlopt.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLOPT=$ac_cv_prog_ac_ct_OCAMLOPT if test -n "$ac_ct_OCAMLOPT"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLOPT" >&5 printf "%s\n" "$ac_ct_OCAMLOPT" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLOPT" = x; then OCAMLOPT="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLOPT=$ac_ct_OCAMLOPT fi else OCAMLOPT="$ac_cv_prog_OCAMLOPT" fi if test "x$OCAMLOPT" = "x" then : if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlopt", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlopt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLOPT+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLOPT"; then ac_cv_prog_OCAMLOPT="$OCAMLOPT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLOPT="${ac_tool_prefix}ocamlopt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLOPT=$ac_cv_prog_OCAMLOPT if test -n "$OCAMLOPT"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLOPT" >&5 printf "%s\n" "$OCAMLOPT" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLOPT"; then ac_ct_OCAMLOPT=$OCAMLOPT # Extract the first word of "ocamlopt", so it can be a program name with args. set dummy ocamlopt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLOPT+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLOPT"; then ac_cv_prog_ac_ct_OCAMLOPT="$ac_ct_OCAMLOPT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLOPT="ocamlopt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLOPT=$ac_cv_prog_ac_ct_OCAMLOPT if test -n "$ac_ct_OCAMLOPT"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLOPT" >&5 printf "%s\n" "$ac_ct_OCAMLOPT" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLOPT" = x; then OCAMLOPT="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLOPT=$ac_ct_OCAMLOPT fi else OCAMLOPT="$ac_cv_prog_OCAMLOPT" fi fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamldoc.opt", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamldoc.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLDOC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLDOC"; then ac_cv_prog_OCAMLDOC="$OCAMLDOC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDOC="${ac_tool_prefix}ocamldoc.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLDOC=$ac_cv_prog_OCAMLDOC if test -n "$OCAMLDOC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLDOC" >&5 printf "%s\n" "$OCAMLDOC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLDOC"; then ac_ct_OCAMLDOC=$OCAMLDOC # Extract the first word of "ocamldoc.opt", so it can be a program name with args. set dummy ocamldoc.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLDOC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLDOC"; then ac_cv_prog_ac_ct_OCAMLDOC="$ac_ct_OCAMLDOC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDOC="ocamldoc.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLDOC=$ac_cv_prog_ac_ct_OCAMLDOC if test -n "$ac_ct_OCAMLDOC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLDOC" >&5 printf "%s\n" "$ac_ct_OCAMLDOC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLDOC" = x; then OCAMLDOC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLDOC=$ac_ct_OCAMLDOC fi else OCAMLDOC="$ac_cv_prog_OCAMLDOC" fi if test "x$OCAMLDOC" = "x" then : if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamldoc", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamldoc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLDOC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLDOC"; then ac_cv_prog_OCAMLDOC="$OCAMLDOC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDOC="${ac_tool_prefix}ocamldoc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLDOC=$ac_cv_prog_OCAMLDOC if test -n "$OCAMLDOC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLDOC" >&5 printf "%s\n" "$OCAMLDOC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLDOC"; then ac_ct_OCAMLDOC=$OCAMLDOC # Extract the first word of "ocamldoc", so it can be a program name with args. set dummy ocamldoc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLDOC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLDOC"; then ac_cv_prog_ac_ct_OCAMLDOC="$ac_ct_OCAMLDOC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDOC="ocamldoc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLDOC=$ac_cv_prog_ac_ct_OCAMLDOC if test -n "$ac_ct_OCAMLDOC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLDOC" >&5 printf "%s\n" "$ac_ct_OCAMLDOC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLDOC" = x; then OCAMLDOC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLDOC=$ac_ct_OCAMLDOC fi else OCAMLDOC="$ac_cv_prog_OCAMLDOC" fi fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamldep.opt", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamldep.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLDEP+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLDEP"; then ac_cv_prog_OCAMLDEP="$OCAMLDEP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDEP="${ac_tool_prefix}ocamldep.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLDEP=$ac_cv_prog_OCAMLDEP if test -n "$OCAMLDEP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLDEP" >&5 printf "%s\n" "$OCAMLDEP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLDEP"; then ac_ct_OCAMLDEP=$OCAMLDEP # Extract the first word of "ocamldep.opt", so it can be a program name with args. set dummy ocamldep.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLDEP+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLDEP"; then ac_cv_prog_ac_ct_OCAMLDEP="$ac_ct_OCAMLDEP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDEP="ocamldep.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLDEP=$ac_cv_prog_ac_ct_OCAMLDEP if test -n "$ac_ct_OCAMLDEP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLDEP" >&5 printf "%s\n" "$ac_ct_OCAMLDEP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLDEP" = x; then OCAMLDEP="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLDEP=$ac_ct_OCAMLDEP fi else OCAMLDEP="$ac_cv_prog_OCAMLDEP" fi if test "x$OCAMLDEP" = "x" then : if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamldep", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamldep; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLDEP+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLDEP"; then ac_cv_prog_OCAMLDEP="$OCAMLDEP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDEP="${ac_tool_prefix}ocamldep" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLDEP=$ac_cv_prog_OCAMLDEP if test -n "$OCAMLDEP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLDEP" >&5 printf "%s\n" "$OCAMLDEP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLDEP"; then ac_ct_OCAMLDEP=$OCAMLDEP # Extract the first word of "ocamldep", so it can be a program name with args. set dummy ocamldep; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLDEP+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLDEP"; then ac_cv_prog_ac_ct_OCAMLDEP="$ac_ct_OCAMLDEP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDEP="ocamldep" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLDEP=$ac_cv_prog_ac_ct_OCAMLDEP if test -n "$ac_ct_OCAMLDEP"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLDEP" >&5 printf "%s\n" "$ac_ct_OCAMLDEP" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLDEP" = x; then OCAMLDEP="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLDEP=$ac_ct_OCAMLDEP fi else OCAMLDEP="$ac_cv_prog_OCAMLDEP" fi fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlmklib.opt", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlmklib.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLMKLIB+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLMKLIB"; then ac_cv_prog_OCAMLMKLIB="$OCAMLMKLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLMKLIB="${ac_tool_prefix}ocamlmklib.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLMKLIB=$ac_cv_prog_OCAMLMKLIB if test -n "$OCAMLMKLIB"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLMKLIB" >&5 printf "%s\n" "$OCAMLMKLIB" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLMKLIB"; then ac_ct_OCAMLMKLIB=$OCAMLMKLIB # Extract the first word of "ocamlmklib.opt", so it can be a program name with args. set dummy ocamlmklib.opt; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLMKLIB+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLMKLIB"; then ac_cv_prog_ac_ct_OCAMLMKLIB="$ac_ct_OCAMLMKLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLMKLIB="ocamlmklib.opt" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLMKLIB=$ac_cv_prog_ac_ct_OCAMLMKLIB if test -n "$ac_ct_OCAMLMKLIB"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLMKLIB" >&5 printf "%s\n" "$ac_ct_OCAMLMKLIB" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLMKLIB" = x; then OCAMLMKLIB="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLMKLIB=$ac_ct_OCAMLMKLIB fi else OCAMLMKLIB="$ac_cv_prog_OCAMLMKLIB" fi if test "x$OCAMLMKLIB" = "x" then : if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ocamlmklib", so it can be a program name with args. set dummy ${ac_tool_prefix}ocamlmklib; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OCAMLMKLIB+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$OCAMLMKLIB"; then ac_cv_prog_OCAMLMKLIB="$OCAMLMKLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLMKLIB="${ac_tool_prefix}ocamlmklib" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi OCAMLMKLIB=$ac_cv_prog_OCAMLMKLIB if test -n "$OCAMLMKLIB"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAMLMKLIB" >&5 printf "%s\n" "$OCAMLMKLIB" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_OCAMLMKLIB"; then ac_ct_OCAMLMKLIB=$OCAMLMKLIB # Extract the first word of "ocamlmklib", so it can be a program name with args. set dummy ocamlmklib; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OCAMLMKLIB+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_OCAMLMKLIB"; then ac_cv_prog_ac_ct_OCAMLMKLIB="$ac_ct_OCAMLMKLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLMKLIB="ocamlmklib" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_OCAMLMKLIB=$ac_cv_prog_ac_ct_OCAMLMKLIB if test -n "$ac_ct_OCAMLMKLIB"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OCAMLMKLIB" >&5 printf "%s\n" "$ac_ct_OCAMLMKLIB" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_OCAMLMKLIB" = x; then OCAMLMKLIB="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OCAMLMKLIB=$ac_ct_OCAMLMKLIB fi else OCAMLMKLIB="$ac_cv_prog_OCAMLMKLIB" fi fi else case e in #( e) OCAMLC="$OCAMLFIND ocamlc" OCAMLOPT="$OCAMLFIND ocamlopt" OCAMLDOC="$OCAMLFIND ocamldoc" OCAMLDEP="$OCAMLFIND ocamldep" OCAMLMKLIB="$OCAMLFIND ocamlmklib" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ocamlfind package result" >&5 printf %s "checking for ocamlfind package result... " >&6; } if $OCAMLFIND query result >/dev/null 2>&1 then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if package result is usable" >&5 printf %s "checking if package result is usable... " >&6; } echo "module M = Result" > configure_test.ml if $OCAMLFIND c -package result configure_test.ml -o configure_test.out >/dev/null 2>&1 then : rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } RESULT_PKG=result else case e in #( e) rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } ;; esac fi else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ocamlfind package seq" >&5 printf %s "checking for ocamlfind package seq... " >&6; } if $OCAMLFIND query seq >/dev/null 2>&1 then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if package seq is usable" >&5 printf %s "checking if package seq is usable... " >&6; } echo "module M = Seq" > configure_test.ml if $OCAMLFIND c -package seq configure_test.ml -o configure_test.out >/dev/null 2>&1 then : rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } SEQ_PKG=seq else case e in #( e) rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } ;; esac fi else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ocamlfind package uchar" >&5 printf %s "checking for ocamlfind package uchar... " >&6; } if $OCAMLFIND query uchar >/dev/null 2>&1 then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if package uchar is usable" >&5 printf %s "checking if package uchar is usable... " >&6; } echo "module M = Uchar" > configure_test.ml if $OCAMLFIND c -package uchar configure_test.ml -o configure_test.out >/dev/null 2>&1 then : rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } UCHAR_PKG=uchar else case e in #( e) rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } ;; esac fi else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } ;; esac fi ;; esac fi if test "x$OCAMLOPT" = "x" then : if test "x$OCAMLC" = "x" then : as_fn_error $? "No OCaml compiler available" "$LINENO" 5 else case e in #( e) OCAMLBEST="$OCAMLC" CMAX="cma" ;; esac fi else case e in #( e) OCAMLBEST="$OCAMLOPT" CMAX="cmxa" ;; esac fi if test "x$OCAMLDEP" = "x" then : as_fn_error $? "No ocamldep available" "$LINENO" 5 fi ac_config_headers="$ac_config_headers config.h" DEPDIR="${am__leading_dot}deps" ac_config_commands="$ac_config_commands depfiles" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5 printf %s "checking whether ${MAKE-make} supports the include directive... " >&6; } cat > confinc.mk << 'END' am__doit: @echo this is the am__doit target >confinc.out .PHONY: am__doit END am__include="#" am__quote= # BSD make does it like this. echo '.include "confinc.mk" # ignored' > confmf.BSD # Other make implementations (GNU, Solaris 10, AIX) do it like this. echo 'include confinc.mk # ignored' > confmf.GNU _am_result=no for s in GNU BSD; do { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5 (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } case $?:`cat confinc.out 2>/dev/null` in #( '0:this is the am__doit target') : case $s in #( BSD) : am__include='.include' am__quote='"' ;; #( *) : am__include='include' am__quote='' ;; esac ;; #( *) : ;; esac if test "$am__include" != "#"; then _am_result="yes ($s style)" break fi done rm -f confinc.* confmf.* { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5 printf "%s\n" "${_am_result}" >&6; } # Check whether --enable-dependency-tracking was given. if test ${enable_dependency_tracking+y} then : enableval=$enable_dependency_tracking; fi if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' am__nodep='_no' fi if test "x$enable_dependency_tracking" != xno; then AMDEP_TRUE= AMDEP_FALSE='#' else AMDEP_TRUE='#' AMDEP_FALSE= fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 printf "%s\n" "$ac_ct_CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@" fi fi fi ;; esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 printf "%s\n" "$ac_ct_CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args. set dummy ${ac_tool_prefix}clang; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}clang" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 printf "%s\n" "$CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "clang", so it can be a program name with args. set dummy clang; ac_word=$2 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="clang" printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi ;; esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 printf "%s\n" "$ac_ct_CC" >&6; } else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi fi test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See 'config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion -version; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 printf %s "checking whether the C compiler works... " >&6; } ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'. # So ignore a value of 'no', otherwise this would lead to 'EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an '-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else case e in #( e) ac_file='' ;; esac fi if test -z "$ac_file" then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See 'config.log' for more details" "$LINENO" 5; } else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 printf "%s\n" "yes" >&6; } ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 printf %s "checking for C compiler default output file name... " >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 printf "%s\n" "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 printf %s "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # If both 'conftest.exe' and 'conftest' are 'present' (well, observable) # catch 'conftest.exe'. For instance with Cygwin, 'ls conftest' will # work properly (i.e., refer to 'conftest.exe'), while it won't with # 'rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else case e in #( e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See 'config.log' for more details" "$LINENO" 5; } ;; esac fi rm -f conftest conftest$ac_cv_exeext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 printf "%s\n" "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { FILE *f = fopen ("conftest.out", "w"); if (!f) return 1; return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 printf %s "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "cannot run C compiled programs. If you meant to cross compile, use '--host'. See 'config.log' for more details" "$LINENO" 5; } fi fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 printf "%s\n" "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext \ conftest.o conftest.obj conftest.out ac_clean_files=$ac_clean_files_save { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 printf %s "checking for suffix of object files... " >&6; } if test ${ac_cv_objext+y} then : printf %s "(cached) " >&6 else case e in #( e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else case e in #( e) printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See 'config.log' for more details" "$LINENO" 5; } ;; esac fi rm -f conftest.$ac_cv_objext conftest.$ac_ext ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 printf "%s\n" "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 printf %s "checking whether the compiler supports GNU C... " >&6; } if test ${ac_cv_c_compiler_gnu+y} then : printf %s "(cached) " >&6 else case e in #( e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_compiler_gnu=yes else case e in #( e) ac_compiler_gnu=no ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_c_compiler_gnu if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+y} ac_save_CFLAGS=$CFLAGS { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 printf %s "checking whether $CC accepts -g... " >&6; } if test ${ac_cv_prog_cc_g+y} then : printf %s "(cached) " >&6 else case e in #( e) ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes else case e in #( e) CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : else case e in #( e) ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 printf "%s\n" "$ac_cv_prog_cc_g" >&6; } if test $ac_test_CFLAGS; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi ac_prog_cc_stdc=no if test x$ac_prog_cc_stdc = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 printf %s "checking for $CC option to enable C11 features... " >&6; } if test ${ac_cv_prog_cc_c11+y} then : printf %s "(cached) " >&6 else case e in #( e) ac_cv_prog_cc_c11=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c11_program _ACEOF for ac_arg in '' -std=gnu11 do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c11=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c11" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC ;; esac fi if test "x$ac_cv_prog_cc_c11" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } else case e in #( e) if test "x$ac_cv_prog_cc_c11" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } CC="$CC $ac_cv_prog_cc_c11" ;; esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 ac_prog_cc_stdc=c11 ;; esac fi fi if test x$ac_prog_cc_stdc = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 printf %s "checking for $CC option to enable C99 features... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : printf %s "(cached) " >&6 else case e in #( e) ac_cv_prog_cc_c99=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c99_program _ACEOF for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99= do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c99=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC ;; esac fi if test "x$ac_cv_prog_cc_c99" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } else case e in #( e) if test "x$ac_cv_prog_cc_c99" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } CC="$CC $ac_cv_prog_cc_c99" ;; esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 ac_prog_cc_stdc=c99 ;; esac fi fi if test x$ac_prog_cc_stdc = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 printf %s "checking for $CC option to enable C89 features... " >&6; } if test ${ac_cv_prog_cc_c89+y} then : printf %s "(cached) " >&6 else case e in #( e) ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c89_program _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC ;; esac fi if test "x$ac_cv_prog_cc_c89" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } else case e in #( e) if test "x$ac_cv_prog_cc_c89" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } CC="$CC $ac_cv_prog_cc_c89" ;; esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 ac_prog_cc_stdc=c89 ;; esac fi fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5 printf %s "checking whether $CC understands -c and -o together... " >&6; } if test ${am_cv_prog_cc_c_o+y} then : printf %s "(cached) " >&6 else case e in #( e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main (void) { ; return 0; } _ACEOF # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5 ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 printf "%s\n" "$am_cv_prog_cc_c_o" >&6; } if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # But if we don't then we get into trouble of one sort or another. # A longer-term fix would be to have automake use am__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu depcc="$CC" am_compiler_list= { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CC_dependencies_compiler_type+y} then : printf %s "(cached) " >&6 else case e in #( e) if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named 'D' -- because '-MD' means "put the output # in D". rm -rf conftest.dir mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CC_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with # Solaris 10 /bin/sh. echo '/* dummy */' > sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with '-c' and '-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle '-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs. am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # After this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested. if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvc7 | msvc7msys | msvisualcpp | msvcmsys) # This compiler won't grok '-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CC_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then am__fastdepCC_TRUE= am__fastdepCC_FALSE='#' else am__fastdepCC_TRUE='#' am__fastdepCC_FALSE= fi ac_header= ac_cache= for ac_item in $ac_header_c_list do if test $ac_cache; then ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default" if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then printf "%s\n" "#define $ac_item 1" >> confdefs.h fi ac_header= ac_cache= elif test $ac_header; then ac_cache=$ac_item else ac_header=$ac_item fi done if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes then : printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 printf %s "checking whether byte ordering is bigendian... " >&6; } if test ${ac_cv_c_bigendian+y} then : printf %s "(cached) " >&6 else case e in #( e) ac_cv_c_bigendian=unknown # See if we're dealing with a universal compiler. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __APPLE_CC__ not a universal capable compiler #endif typedef int dummy; _ACEOF if ac_fn_c_try_compile "$LINENO" then : # Check for potential -arch flags. It is not universal unless # there are at least two -arch flags with different values. ac_arch= ac_prev= for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do if test -n "$ac_prev"; then case $ac_word in i?86 | x86_64 | ppc | ppc64) if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then ac_arch=$ac_word else ac_cv_c_bigendian=universal break fi ;; esac ac_prev= elif test "x$ac_word" = "x-arch"; then ac_prev=arch fi done fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext if test $ac_cv_c_bigendian = unknown; then # See if sys/param.h defines the BYTE_ORDER macro. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main (void) { #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \\ && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \\ && LITTLE_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : # It does; now see whether it defined to BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main (void) { #if BYTE_ORDER != BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_bigendian=yes else case e in #( e) ac_cv_c_bigendian=no ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : # It does; now see whether it defined to _BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main (void) { #ifndef _BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_bigendian=yes else case e in #( e) ac_cv_c_bigendian=no ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # Compile a test program. if test "$cross_compiling" = yes then : # Try to guess by grepping values from an object file. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ unsigned short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; unsigned short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; int use_ascii (int i) { return ascii_mm[i] + ascii_ii[i]; } unsigned short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; unsigned short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; int use_ebcdic (int i) { return ebcdic_mm[i] + ebcdic_ii[i]; } int main (int argc, char **argv) { /* Intimidate the compiler so that it does not optimize the arrays away. */ char *p = argv[0]; ascii_mm[1] = *p++; ebcdic_mm[1] = *p++; ascii_ii[1] = *p++; ebcdic_ii[1] = *p++; return use_ascii (argc) == use_ebcdic (*p); } _ACEOF if ac_fn_c_try_link "$LINENO" then : if grep BIGenDianSyS conftest$ac_exeext >/dev/null; then ac_cv_c_bigendian=yes fi if grep LiTTleEnDian conftest$ac_exeext >/dev/null ; then if test "$ac_cv_c_bigendian" = unknown; then ac_cv_c_bigendian=no else # finding both strings is unlikely to happen, but who knows? ac_cv_c_bigendian=unknown fi fi fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext else case e in #( e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main (void) { /* Are we little or big endian? From Harbison&Steele. */ union { long int l; char c[sizeof (long int)]; } u; u.l = 1; return u.c[sizeof (long int) - 1] == 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO" then : ac_cv_c_bigendian=no else case e in #( e) ac_cv_c_bigendian=yes ;; esac fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi fi ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5 printf "%s\n" "$ac_cv_c_bigendian" >&6; } case $ac_cv_c_bigendian in #( yes) BIG_ENDIAN=true ;; #( no) BIG_ENDIAN=false ;; #( universal) printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h ;; #( *) as_fn_error $? "Unknown endianness" "$LINENO" 5 ;; esac { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking OCaml target OS type" >&5 printf %s "checking OCaml target OS type... " >&6; } if test `printf "$OCAMLVERSION\n3.12.0" | sort | head -n1` = 3.12.0 then : target_os_type=`$OCAMLBEST -config | sed -n 's/^os_type: \(.*\)$/\1/p' | sed 's/\r//'` else case e in #( e) target_os_type=`echo 'Sys.os_type;;' | $OCAML | sed -n 's/^\# - : string = "\(.*\)"$/\1/p'` ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_os_type" >&5 printf "%s\n" "$target_os_type" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for flambda2" >&5 printf %s "checking for flambda2... " >&6; } if test "$OCAML_VERSION_MAJOR" -ge 4 then : OCAML_FLAMBDA2=`$OCAMLBEST -config | sed -n 's/^flambda2: \(.*\)$/\1/p' | sed 's/\r//'` if test "x$OCAML_FLAMBDA2" = "x" then : OCAML_FLAMBDA2=false fi else case e in #( e) OCAML_FLAMBDA2=false ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OCAML_FLAMBDA2" >&5 printf "%s\n" "$OCAML_FLAMBDA2" >&6; } # Check whether --enable-magic was given. if test ${enable_magic+y} then : enableval=$enable_magic; else case e in #( e) enable_magic=yes ;; esac fi if test "x$enable_magic" = "xno" then : BEGIN_WITH_MAGIC='(*' END_WITH_MAGIC='*)' C_BEGIN_WITH_MAGIC='#if 0' C_END_WITH_MAGIC='#endif' else case e in #( e) BEGIN_WITHOUT_MAGIC='(*' END_WITHOUT_MAGIC='*)' C_BEGIN_WITHOUT_MAGIC='#if 0' C_END_WITHOUT_MAGIC='#endif' ;; esac fi if test "x$RESULT_PKG" = "x" then : BEGIN_WITH_RESULT_PKG='(*' END_WITH_RESULT_PKG='*)' C_BEGIN_WITH_RESULT_PKG='#if 0' C_END_WITH_RESULT_PKG='#endif' else case e in #( e) BEGIN_WITHOUT_RESULT_PKG='(*' END_WITHOUT_RESULT_PKG='*)' C_BEGIN_WITHOUT_RESULT_PKG='#if 0' C_END_WITHOUT_RESULT_PKG='#endif' ;; esac fi if test "x$SEQ_PKG" = "x" then : BEGIN_WITH_SEQ_PKG='(*' END_WITH_SEQ_PKG='*)' C_BEGIN_WITH_SEQ_PKG='#if 0' C_END_WITH_SEQ_PKG='#endif' else case e in #( e) BEGIN_WITHOUT_SEQ_PKG='(*' END_WITHOUT_SEQ_PKG='*)' C_BEGIN_WITHOUT_SEQ_PKG='#if 0' C_END_WITHOUT_SEQ_PKG='#endif' ;; esac fi if test "x$UCHAR_PKG" = "x" then : BEGIN_WITH_UCHAR_PKG='(*' END_WITH_UCHAR_PKG='*)' C_BEGIN_WITH_UCHAR_PKG='#if 0' C_END_WITH_UCHAR_PKG='#endif' else case e in #( e) BEGIN_WITHOUT_UCHAR_PKG='(*' END_WITHOUT_UCHAR_PKG='*)' C_BEGIN_WITHOUT_UCHAR_PKG='#if 0' C_END_WITHOUT_UCHAR_PKG='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n3.07" | sort | head -n1` = 3.07 then : BEGIN_BEFORE_3_07_0='(*' END_BEFORE_3_07_0='*)' C_BEGIN_BEFORE_3_07_0='#if 0' C_END_BEFORE_3_07_0='#endif' else case e in #( e) BEGIN_FROM_3_07_0='(*' END_FROM_3_07_0='*)' C_BEGIN_FROM_3_07_0='#if 0' C_END_FROM_3_07_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n3.08.0" | sort | head -n1` = 3.08.0 then : BEGIN_BEFORE_3_08_0='(*' END_BEFORE_3_08_0='*)' C_BEGIN_BEFORE_3_08_0='#if 0' C_END_BEFORE_3_08_0='#endif' else case e in #( e) BEGIN_FROM_3_08_0='(*' END_FROM_3_08_0='*)' C_BEGIN_FROM_3_08_0='#if 0' C_END_FROM_3_08_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n3.09.0" | sort | head -n1` = 3.09.0 then : BEGIN_BEFORE_3_09_0='(*' END_BEFORE_3_09_0='*)' C_BEGIN_BEFORE_3_09_0='#if 0' C_END_BEFORE_3_09_0='#endif' else case e in #( e) BEGIN_FROM_3_09_0='(*' END_FROM_3_09_0='*)' C_BEGIN_FROM_3_09_0='#if 0' C_END_FROM_3_09_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n3.10.0" | sort | head -n1` = 3.10.0 then : BEGIN_BEFORE_3_10_0='(*' END_BEFORE_3_10_0='*)' C_BEGIN_BEFORE_3_10_0='#if 0' C_END_BEFORE_3_10_0='#endif' else case e in #( e) BEGIN_FROM_3_10_0='(*' END_FROM_3_10_0='*)' C_BEGIN_FROM_3_10_0='#if 0' C_END_FROM_3_10_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n3.11.0" | sort | head -n1` = 3.11.0 then : BEGIN_BEFORE_3_11_0='(*' END_BEFORE_3_11_0='*)' C_BEGIN_BEFORE_3_11_0='#if 0' C_END_BEFORE_3_11_0='#endif' else case e in #( e) BEGIN_FROM_3_11_0='(*' END_FROM_3_11_0='*)' C_BEGIN_FROM_3_11_0='#if 0' C_END_FROM_3_11_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n3.12.0" | sort | head -n1` = 3.12.0 then : BEGIN_BEFORE_3_12_0='(*' END_BEFORE_3_12_0='*)' C_BEGIN_BEFORE_3_12_0='#if 0' C_END_BEFORE_3_12_0='#endif' else case e in #( e) BEGIN_FROM_3_12_0='(*' END_FROM_3_12_0='*)' C_BEGIN_FROM_3_12_0='#if 0' C_END_FROM_3_12_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.00.0" | sort | head -n1` = 4.00.0 then : BEGIN_BEFORE_4_00_0='(*' END_BEFORE_4_00_0='*)' C_BEGIN_BEFORE_4_00_0='#if 0' C_END_BEFORE_4_00_0='#endif' else case e in #( e) BEGIN_FROM_4_00_0='(*' END_FROM_4_00_0='*)' C_BEGIN_FROM_4_00_0='#if 0' C_END_FROM_4_00_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.01.0" | sort | head -n1` = 4.01.0 then : BEGIN_BEFORE_4_01_0='(*' END_BEFORE_4_01_0='*)' C_BEGIN_BEFORE_4_01_0='#if 0' C_END_BEFORE_4_01_0='#endif' else case e in #( e) BEGIN_FROM_4_01_0='(*' END_FROM_4_01_0='*)' C_BEGIN_FROM_4_01_0='#if 0' C_END_FROM_4_01_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.02.0" | sort | head -n1` = 4.02.0 then : BEGIN_BEFORE_4_02_0='(*' END_BEFORE_4_02_0='*)' C_BEGIN_BEFORE_4_02_0='#if 0' C_END_BEFORE_4_02_0='#endif' else case e in #( e) BEGIN_FROM_4_02_0='(*' END_FROM_4_02_0='*)' C_BEGIN_FROM_4_02_0='#if 0' C_END_FROM_4_02_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.03.0" | sort | head -n1` = 4.03.0 then : BEGIN_BEFORE_4_03_0='(*' END_BEFORE_4_03_0='*)' C_BEGIN_BEFORE_4_03_0='#if 0' C_END_BEFORE_4_03_0='#endif' else case e in #( e) BEGIN_FROM_4_03_0='(*' END_FROM_4_03_0='*)' C_BEGIN_FROM_4_03_0='#if 0' C_END_FROM_4_03_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.04.0" | sort | head -n1` = 4.04.0 then : BEGIN_BEFORE_4_04_0='(*' END_BEFORE_4_04_0='*)' C_BEGIN_BEFORE_4_04_0='#if 0' C_END_BEFORE_4_04_0='#endif' else case e in #( e) BEGIN_FROM_4_04_0='(*' END_FROM_4_04_0='*)' C_BEGIN_FROM_4_04_0='#if 0' C_END_FROM_4_04_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.05.0" | sort | head -n1` = 4.05.0 then : BEGIN_BEFORE_4_05_0='(*' END_BEFORE_4_05_0='*)' C_BEGIN_BEFORE_4_05_0='#if 0' C_END_BEFORE_4_05_0='#endif' else case e in #( e) BEGIN_FROM_4_05_0='(*' END_FROM_4_05_0='*)' C_BEGIN_FROM_4_05_0='#if 0' C_END_FROM_4_05_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.06.0" | sort | head -n1` = 4.06.0 then : BEGIN_BEFORE_4_06_0='(*' END_BEFORE_4_06_0='*)' C_BEGIN_BEFORE_4_06_0='#if 0' C_END_BEFORE_4_06_0='#endif' else case e in #( e) BEGIN_FROM_4_06_0='(*' END_FROM_4_06_0='*)' C_BEGIN_FROM_4_06_0='#if 0' C_END_FROM_4_06_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.07.0" | sort | head -n1` = 4.07.0 then : BEGIN_BEFORE_4_07_0='(*' END_BEFORE_4_07_0='*)' C_BEGIN_BEFORE_4_07_0='#if 0' C_END_BEFORE_4_07_0='#endif' else case e in #( e) BEGIN_FROM_4_07_0='(*' END_FROM_4_07_0='*)' C_BEGIN_FROM_4_07_0='#if 0' C_END_FROM_4_07_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.07.1" | sort | head -n1` = 4.07.1 then : BEGIN_BEFORE_4_07_1='(*' END_BEFORE_4_07_1='*)' C_BEGIN_BEFORE_4_07_1='#if 0' C_END_BEFORE_4_07_1='#endif' else case e in #( e) BEGIN_FROM_4_07_1='(*' END_FROM_4_07_1='*)' C_BEGIN_FROM_4_07_1='#if 0' C_END_FROM_4_07_1='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.08.0" | sort | head -n1` = 4.08.0 then : BEGIN_BEFORE_4_08_0='(*' END_BEFORE_4_08_0='*)' C_BEGIN_BEFORE_4_08_0='#if 0' C_END_BEFORE_4_08_0='#endif' else case e in #( e) BEGIN_FROM_4_08_0='(*' END_FROM_4_08_0='*)' C_BEGIN_FROM_4_08_0='#if 0' C_END_FROM_4_08_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.09.0" | sort | head -n1` = 4.09.0 then : BEGIN_BEFORE_4_09_0='(*' END_BEFORE_4_09_0='*)' C_BEGIN_BEFORE_4_09_0='#if 0' C_END_BEFORE_4_09_0='#endif' else case e in #( e) BEGIN_FROM_4_09_0='(*' END_FROM_4_09_0='*)' C_BEGIN_FROM_4_09_0='#if 0' C_END_FROM_4_09_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.10.0" | sort | head -n1` = 4.10.0 then : BEGIN_BEFORE_4_10_0='(*' END_BEFORE_4_10_0='*)' C_BEGIN_BEFORE_4_10_0='#if 0' C_END_BEFORE_4_10_0='#endif' else case e in #( e) BEGIN_FROM_4_10_0='(*' END_FROM_4_10_0='*)' C_BEGIN_FROM_4_10_0='#if 0' C_END_FROM_4_10_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.11.0" | sort | head -n1` = 4.11.0 then : BEGIN_BEFORE_4_11_0='(*' END_BEFORE_4_11_0='*)' C_BEGIN_BEFORE_4_11_0='#if 0' C_END_BEFORE_4_11_0='#endif' else case e in #( e) BEGIN_FROM_4_11_0='(*' END_FROM_4_11_0='*)' C_BEGIN_FROM_4_11_0='#if 0' C_END_FROM_4_11_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.12.0" | sort | head -n1` = 4.12.0 then : BEGIN_BEFORE_4_12_0='(*' END_BEFORE_4_12_0='*)' C_BEGIN_BEFORE_4_12_0='#if 0' C_END_BEFORE_4_12_0='#endif' else case e in #( e) BEGIN_FROM_4_12_0='(*' END_FROM_4_12_0='*)' C_BEGIN_FROM_4_12_0='#if 0' C_END_FROM_4_12_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.13.0" | sort | head -n1` = 4.13.0 then : BEGIN_BEFORE_4_13_0='(*' END_BEFORE_4_13_0='*)' C_BEGIN_BEFORE_4_13_0='#if 0' C_END_BEFORE_4_13_0='#endif' else case e in #( e) BEGIN_FROM_4_13_0='(*' END_FROM_4_13_0='*)' C_BEGIN_FROM_4_13_0='#if 0' C_END_FROM_4_13_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n4.14.0" | sort | head -n1` = 4.14.0 then : BEGIN_BEFORE_4_14_0='(*' END_BEFORE_4_14_0='*)' C_BEGIN_BEFORE_4_14_0='#if 0' C_END_BEFORE_4_14_0='#endif' else case e in #( e) BEGIN_FROM_4_14_0='(*' END_FROM_4_14_0='*)' C_BEGIN_FROM_4_14_0='#if 0' C_END_FROM_4_14_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n5.0.0" | sort | head -n1` = 5.0.0 then : BEGIN_BEFORE_5_0_0='(*' END_BEFORE_5_0_0='*)' C_BEGIN_BEFORE_5_0_0='#if 0' C_END_BEFORE_5_0_0='#endif' else case e in #( e) BEGIN_FROM_5_0_0='(*' END_FROM_5_0_0='*)' C_BEGIN_FROM_5_0_0='#if 0' C_END_FROM_5_0_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n5.1.0" | sort | head -n1` = 5.1.0 then : BEGIN_BEFORE_5_1_0='(*' END_BEFORE_5_1_0='*)' C_BEGIN_BEFORE_5_1_0='#if 0' C_END_BEFORE_5_1_0='#endif' else case e in #( e) BEGIN_FROM_5_1_0='(*' END_FROM_5_1_0='*)' C_BEGIN_FROM_5_1_0='#if 0' C_END_FROM_5_1_0='#endif' ;; esac fi if test `printf "$OCAMLVERSION\n5.2.0" | sort | head -n1` = 5.2.0 then : BEGIN_BEFORE_5_2_0='(*' END_BEFORE_5_2_0='*)' C_BEGIN_BEFORE_5_2_0='#if 0' C_END_BEFORE_5_2_0='#endif' else case e in #( e) BEGIN_FROM_5_2_0='(*' END_FROM_5_2_0='*)' C_BEGIN_FROM_5_2_0='#if 0' C_END_FROM_5_2_0='#endif' ;; esac fi if test "x$target_os_type" = "xWin32" then : BEGIN_WITHOUT_WIN32='(*' END_WITHOUT_WIN32='*)' C_BEGIN_WITHOUT_WIN32='#if 0' C_END_WITHOUT_WIN32='#endif' else case e in #( e) BEGIN_WITH_WIN32='(*' END_WITH_WIN32='*)' C_BEGIN_WITH_WIN32='#if 0' C_END_WITH_WIN32='#endif' ;; esac fi if test "x$target_os_type" = "xCygwin" then : BEGIN_WITHOUT_CYGWIN='(*' END_WITHOUT_CYGWIN='*)' C_BEGIN_WITHOUT_CYGWIN='#if 0' C_END_WITHOUT_CYGWIN='#endif' else case e in #( e) BEGIN_WITH_CYGWIN='(*' END_WITH_CYGWIN='*)' C_BEGIN_WITH_CYGWIN='#if 0' C_END_WITH_CYGWIN='#endif' ;; esac fi if test "x$target_os_type" = "xUnix" then : BEGIN_WITHOUT_UNIX='(*' END_WITHOUT_UNIX='*)' C_BEGIN_WITHOUT_UNIX='#if 0' C_END_WITHOUT_UNIX='#endif' else case e in #( e) BEGIN_WITH_UNIX='(*' END_WITH_UNIX='*)' C_BEGIN_WITH_UNIX='#if 0' C_END_WITH_UNIX='#endif' ;; esac fi if test "x$OCAML_FLAMBDA2" = "xtrue" then : BEGIN_WITHOUT_FLAMBDA2='(*' END_WITHOUT_FLAMBDA2='*)' C_BEGIN_WITHOUT_FLAMBDA2='#if 0' C_END_WITHOUT_FLAMBDA2='#endif' else case e in #( e) BEGIN_WITH_FLAMBDA2='(*' END_WITH_FLAMBDA2='*)' C_BEGIN_WITH_FLAMBDA2='#if 0' C_END_WITH_FLAMBDA2='#endif' ;; esac fi if test "x$OCAMLC" != "x"; then OCAML_SUPPORTS_BYTECODE_TRUE= OCAML_SUPPORTS_BYTECODE_FALSE='#' else OCAML_SUPPORTS_BYTECODE_TRUE='#' OCAML_SUPPORTS_BYTECODE_FALSE= fi if test "x$OCAMLOPT" != "x"; then OCAML_SUPPORTS_NATIVE_TRUE= OCAML_SUPPORTS_NATIVE_FALSE='#' else OCAML_SUPPORTS_NATIVE_TRUE='#' OCAML_SUPPORTS_NATIVE_FALSE= fi if test `printf "$OCAMLVERSION\n3.11.1" | sort | head -n1` = 3.11.1; then OCAML_SUPPORTS_SHARED_TRUE= OCAML_SUPPORTS_SHARED_FALSE='#' else OCAML_SUPPORTS_SHARED_TRUE='#' OCAML_SUPPORTS_SHARED_FALSE= fi if test "x$OCAML_SUPPORTS_SHARED_TRUE" = "x" then : SHARED_LIBS="stdcompat.cmxs" else case e in #( e) SHARED_LIBS="" ;; esac fi if test `printf "$OCAMLVERSION\n4.02.0" | sort | head -n1` = 4.02.0; then OCAML_SUPPORTS_NO_ALIAS_DEPS_TRUE= OCAML_SUPPORTS_NO_ALIAS_DEPS_FALSE='#' else OCAML_SUPPORTS_NO_ALIAS_DEPS_TRUE='#' OCAML_SUPPORTS_NO_ALIAS_DEPS_FALSE= fi if test `printf "$OCAMLVERSION\n4.00.0" | sort | head -n1` = 4.00.0; then OCAML_SUPPORTS_BIN_ANNOT_TRUE= OCAML_SUPPORTS_BIN_ANNOT_FALSE='#' else OCAML_SUPPORTS_BIN_ANNOT_TRUE='#' OCAML_SUPPORTS_BIN_ANNOT_FALSE= fi if test `printf "$OCAMLVERSION\n4.08.0" | sort | head -n1` = 4.08.0; then OCAML_SUPPORTS_ALERT_TRUE= OCAML_SUPPORTS_ALERT_FALSE='#' else OCAML_SUPPORTS_ALERT_TRUE='#' OCAML_SUPPORTS_ALERT_FALSE= fi INCLUDE_DEPEND=' ifneq ($(MAKECMDGOALS),clean) ifneq ($(MAKECMDGOALS),distclean) include .depend endif endif ' ac_config_files="$ac_config_files META Makefile" ac_config_files="$ac_config_files stdcompat__hashtbl_ext.mli" ac_config_files="$ac_config_files stdcompat__hashtbl_ext.ml" ac_config_files="$ac_config_files stdcompat__init.mli" ac_config_files="$ac_config_files stdcompat__init.ml:stdcompat__init.mli.in" ac_config_files="$ac_config_files stdcompat__root.mli" ac_config_files="$ac_config_files stdcompat__root.ml" ac_config_files="$ac_config_files stdcompat__tools.mli" ac_config_files="$ac_config_files stdcompat__tools.ml" ac_config_files="$ac_config_files stdcompat__native.ml_byte" ac_config_files="$ac_config_files stdcompat__native.ml_native" ac_config_files="$ac_config_files stdcompat_tests.ml" ac_config_files="$ac_config_files stdcompat.h" ac_config_files="$ac_config_files stdcompat__stubs.c" ac_config_files="$ac_config_files stdcompat__pervasives_s.mli" ac_config_files="$ac_config_files stdcompat__arg_s.mli" ac_config_files="$ac_config_files stdcompat__array_s.mli" ac_config_files="$ac_config_files stdcompat__arrayLabels_s.mli" ac_config_files="$ac_config_files stdcompat__atomic_s.mli" ac_config_files="$ac_config_files stdcompat__bool_s.mli" ac_config_files="$ac_config_files stdcompat__buffer_s.mli" ac_config_files="$ac_config_files stdcompat__bytes_s.mli" ac_config_files="$ac_config_files stdcompat__bytesLabels_s.mli" ac_config_files="$ac_config_files stdcompat__char_s.mli" ac_config_files="$ac_config_files stdcompat__digest_s.mli" ac_config_files="$ac_config_files stdcompat__domain_s.mli" ac_config_files="$ac_config_files stdcompat__either_s.mli" ac_config_files="$ac_config_files stdcompat__ephemeron_s.mli" ac_config_files="$ac_config_files stdcompat__filename_s.mli" ac_config_files="$ac_config_files stdcompat__float_s.mli" ac_config_files="$ac_config_files stdcompat__format_s.mli" ac_config_files="$ac_config_files stdcompat__fun_s.mli" ac_config_files="$ac_config_files stdcompat__hashtbl_s.mli" ac_config_files="$ac_config_files stdcompat__in_channel_s.mli" ac_config_files="$ac_config_files stdcompat__int_s.mli" ac_config_files="$ac_config_files stdcompat__int32_s.mli" ac_config_files="$ac_config_files stdcompat__int64_s.mli" ac_config_files="$ac_config_files stdcompat__lazy_s.mli" ac_config_files="$ac_config_files stdcompat__lexing_s.mli" ac_config_files="$ac_config_files stdcompat__list_s.mli" ac_config_files="$ac_config_files stdcompat__listLabels_s.mli" ac_config_files="$ac_config_files stdcompat__map_s.mli" ac_config_files="$ac_config_files stdcompat__moreLabels_s.mli" ac_config_files="$ac_config_files stdcompat__nativeint_s.mli" ac_config_files="$ac_config_files stdcompat__option_s.mli" ac_config_files="$ac_config_files stdcompat__out_channel_s.mli" ac_config_files="$ac_config_files stdcompat__printexc_s.mli" ac_config_files="$ac_config_files stdcompat__printf_s.mli" ac_config_files="$ac_config_files stdcompat__queue_s.mli" ac_config_files="$ac_config_files stdcompat__random_s.mli" ac_config_files="$ac_config_files stdcompat__result_s.mli" ac_config_files="$ac_config_files stdcompat__seq_s.mli" ac_config_files="$ac_config_files stdcompat__set_s.mli" ac_config_files="$ac_config_files stdcompat__stack_s.mli" ac_config_files="$ac_config_files stdcompat__string_s.mli" ac_config_files="$ac_config_files stdcompat__stringLabels_s.mli" ac_config_files="$ac_config_files stdcompat__sys_s.mli" ac_config_files="$ac_config_files stdcompat__uchar_s.mli" ac_config_files="$ac_config_files stdcompat__weak_s.mli" ac_config_files="$ac_config_files stdcompat__unit_s.mli" ac_config_files="$ac_config_files stdcompat__stdlib_s.mli" ac_config_files="$ac_config_files stdcompat__pervasives_s.ml:stdcompat__pervasives_s.mli.in" ac_config_files="$ac_config_files stdcompat__arg_s.ml:stdcompat__arg_s.mli.in" ac_config_files="$ac_config_files stdcompat__array_s.ml:stdcompat__array_s.mli.in" ac_config_files="$ac_config_files stdcompat__arrayLabels_s.ml:stdcompat__arrayLabels_s.mli.in" ac_config_files="$ac_config_files stdcompat__atomic_s.ml:stdcompat__atomic_s.mli.in" ac_config_files="$ac_config_files stdcompat__bool_s.ml:stdcompat__bool_s.mli.in" ac_config_files="$ac_config_files stdcompat__buffer_s.ml:stdcompat__buffer_s.mli.in" ac_config_files="$ac_config_files stdcompat__bytes_s.ml:stdcompat__bytes_s.mli.in" ac_config_files="$ac_config_files stdcompat__bytesLabels_s.ml:stdcompat__bytesLabels_s.mli.in" ac_config_files="$ac_config_files stdcompat__char_s.ml:stdcompat__char_s.mli.in" ac_config_files="$ac_config_files stdcompat__digest_s.ml:stdcompat__digest_s.mli.in" ac_config_files="$ac_config_files stdcompat__domain_s.ml:stdcompat__domain_s.mli.in" ac_config_files="$ac_config_files stdcompat__either_s.ml:stdcompat__either_s.mli.in" ac_config_files="$ac_config_files stdcompat__ephemeron_s.ml:stdcompat__ephemeron_s.mli.in" ac_config_files="$ac_config_files stdcompat__filename_s.ml:stdcompat__filename_s.mli.in" ac_config_files="$ac_config_files stdcompat__float_s.ml:stdcompat__float_s.mli.in" ac_config_files="$ac_config_files stdcompat__format_s.ml:stdcompat__format_s.mli.in" ac_config_files="$ac_config_files stdcompat__fun_s.ml:stdcompat__fun_s.mli.in" ac_config_files="$ac_config_files stdcompat__hashtbl_s.ml:stdcompat__hashtbl_s.mli.in" ac_config_files="$ac_config_files stdcompat__int_s.ml:stdcompat__int_s.mli.in" ac_config_files="$ac_config_files stdcompat__int32_s.ml:stdcompat__int32_s.mli.in" ac_config_files="$ac_config_files stdcompat__int64_s.ml:stdcompat__int64_s.mli.in" ac_config_files="$ac_config_files stdcompat__lazy_s.ml:stdcompat__lazy_s.mli.in" ac_config_files="$ac_config_files stdcompat__lexing_s.ml:stdcompat__lexing_s.mli.in" ac_config_files="$ac_config_files stdcompat__list_s.ml:stdcompat__list_s.mli.in" ac_config_files="$ac_config_files stdcompat__listLabels_s.ml:stdcompat__listLabels_s.mli.in" ac_config_files="$ac_config_files stdcompat__map_s.ml:stdcompat__map_s.mli.in" ac_config_files="$ac_config_files stdcompat__moreLabels_s.ml:stdcompat__moreLabels_s.mli.in" ac_config_files="$ac_config_files stdcompat__nativeint_s.ml:stdcompat__nativeint_s.mli.in" ac_config_files="$ac_config_files stdcompat__option_s.ml:stdcompat__option_s.mli.in" ac_config_files="$ac_config_files stdcompat__printexc_s.ml:stdcompat__printexc_s.mli.in" ac_config_files="$ac_config_files stdcompat__printf_s.ml:stdcompat__printf_s.mli.in" ac_config_files="$ac_config_files stdcompat__queue_s.ml:stdcompat__queue_s.mli.in" ac_config_files="$ac_config_files stdcompat__random_s.ml:stdcompat__random_s.mli.in" ac_config_files="$ac_config_files stdcompat__result_s.ml:stdcompat__result_s.mli.in" ac_config_files="$ac_config_files stdcompat__seq_s.ml:stdcompat__seq_s.mli.in" ac_config_files="$ac_config_files stdcompat__set_s.ml:stdcompat__set_s.mli.in" ac_config_files="$ac_config_files stdcompat__stack_s.ml:stdcompat__stack_s.mli.in" ac_config_files="$ac_config_files stdcompat__stdlib_s.ml:stdcompat__stdlib_s.mli.in" ac_config_files="$ac_config_files stdcompat__string_s.ml:stdcompat__string_s.mli.in" ac_config_files="$ac_config_files stdcompat__stringLabels_s.ml:stdcompat__stringLabels_s.mli.in" ac_config_files="$ac_config_files stdcompat__sys_s.ml:stdcompat__sys_s.mli.in" ac_config_files="$ac_config_files stdcompat__uchar_s.ml:stdcompat__uchar_s.mli.in" ac_config_files="$ac_config_files stdcompat__weak_s.ml:stdcompat__weak_s.mli.in" ac_config_files="$ac_config_files stdcompat__in_channel_s.ml:stdcompat__in_channel_s.mli.in" ac_config_files="$ac_config_files stdcompat__out_channel_s.ml:stdcompat__out_channel_s.mli.in" ac_config_files="$ac_config_files stdcompat__unit_s.ml:stdcompat__unit_s.mli.in" ac_config_files="$ac_config_files stdcompat__pervasives.ml" ac_config_files="$ac_config_files stdcompat__arg.ml" ac_config_files="$ac_config_files stdcompat__array.ml" ac_config_files="$ac_config_files stdcompat__arrayLabels.ml" ac_config_files="$ac_config_files stdcompat__atomic.ml" ac_config_files="$ac_config_files stdcompat__bool.ml" ac_config_files="$ac_config_files stdcompat__buffer.ml" ac_config_files="$ac_config_files stdcompat__bytes.ml" ac_config_files="$ac_config_files stdcompat__bytesLabels.ml" ac_config_files="$ac_config_files stdcompat__char.ml" ac_config_files="$ac_config_files stdcompat__digest.ml" ac_config_files="$ac_config_files stdcompat__domain.ml" ac_config_files="$ac_config_files stdcompat__either.ml" ac_config_files="$ac_config_files stdcompat__ephemeron.ml" ac_config_files="$ac_config_files stdcompat__filename.ml" ac_config_files="$ac_config_files stdcompat__float.ml" ac_config_files="$ac_config_files stdcompat__format.ml" ac_config_files="$ac_config_files stdcompat__fun.ml" ac_config_files="$ac_config_files stdcompat__hashtbl.ml" ac_config_files="$ac_config_files stdcompat__int.ml" ac_config_files="$ac_config_files stdcompat__int32.ml" ac_config_files="$ac_config_files stdcompat__int64.ml" ac_config_files="$ac_config_files stdcompat__lazy.ml" ac_config_files="$ac_config_files stdcompat__lexing.ml" ac_config_files="$ac_config_files stdcompat__list.ml" ac_config_files="$ac_config_files stdcompat__listLabels.ml" ac_config_files="$ac_config_files stdcompat__map.ml" ac_config_files="$ac_config_files stdcompat__moreLabels.ml" ac_config_files="$ac_config_files stdcompat__nativeint.ml" ac_config_files="$ac_config_files stdcompat__option.ml" ac_config_files="$ac_config_files stdcompat__printexc.ml" ac_config_files="$ac_config_files stdcompat__printf.ml" ac_config_files="$ac_config_files stdcompat__queue.ml" ac_config_files="$ac_config_files stdcompat__random.ml" ac_config_files="$ac_config_files stdcompat__result.ml" ac_config_files="$ac_config_files stdcompat__seq.ml" ac_config_files="$ac_config_files stdcompat__set.ml" ac_config_files="$ac_config_files stdcompat__stack.ml" ac_config_files="$ac_config_files stdcompat__stdlib.ml" ac_config_files="$ac_config_files stdcompat__string.ml" ac_config_files="$ac_config_files stdcompat__stringLabels.ml" ac_config_files="$ac_config_files stdcompat__sys.ml" ac_config_files="$ac_config_files stdcompat__uchar.ml" ac_config_files="$ac_config_files stdcompat__weak.ml" ac_config_files="$ac_config_files stdcompat__in_channel.ml" ac_config_files="$ac_config_files stdcompat__out_channel.ml" ac_config_files="$ac_config_files stdcompat__unit.ml" ac_config_files="$ac_config_files stdcompat__pervasives.mli" ac_config_files="$ac_config_files stdcompat__arg.mli" ac_config_files="$ac_config_files stdcompat__array.mli" ac_config_files="$ac_config_files stdcompat__arrayLabels.mli" ac_config_files="$ac_config_files stdcompat__atomic.mli" ac_config_files="$ac_config_files stdcompat__bool.mli" ac_config_files="$ac_config_files stdcompat__buffer.mli" ac_config_files="$ac_config_files stdcompat__bytes.mli" ac_config_files="$ac_config_files stdcompat__bytesLabels.mli" ac_config_files="$ac_config_files stdcompat__char.mli" ac_config_files="$ac_config_files stdcompat__digest.mli" ac_config_files="$ac_config_files stdcompat__domain.mli" ac_config_files="$ac_config_files stdcompat__either.mli" ac_config_files="$ac_config_files stdcompat__ephemeron.mli" ac_config_files="$ac_config_files stdcompat__filename.mli" ac_config_files="$ac_config_files stdcompat__float.mli" ac_config_files="$ac_config_files stdcompat__format.mli" ac_config_files="$ac_config_files stdcompat__fun.mli" ac_config_files="$ac_config_files stdcompat__hashtbl.mli" ac_config_files="$ac_config_files stdcompat__int.mli" ac_config_files="$ac_config_files stdcompat__int32.mli" ac_config_files="$ac_config_files stdcompat__int64.mli" ac_config_files="$ac_config_files stdcompat__lazy.mli" ac_config_files="$ac_config_files stdcompat__lexing.mli" ac_config_files="$ac_config_files stdcompat__list.mli" ac_config_files="$ac_config_files stdcompat__listLabels.mli" ac_config_files="$ac_config_files stdcompat__map.mli" ac_config_files="$ac_config_files stdcompat__moreLabels.mli" ac_config_files="$ac_config_files stdcompat__nativeint.mli" ac_config_files="$ac_config_files stdcompat__option.mli" ac_config_files="$ac_config_files stdcompat__printexc.mli" ac_config_files="$ac_config_files stdcompat__printf.mli" ac_config_files="$ac_config_files stdcompat__queue.mli" ac_config_files="$ac_config_files stdcompat__random.mli" ac_config_files="$ac_config_files stdcompat__result.mli" ac_config_files="$ac_config_files stdcompat__seq.mli" ac_config_files="$ac_config_files stdcompat__set.mli" ac_config_files="$ac_config_files stdcompat__stack.mli" ac_config_files="$ac_config_files stdcompat__stdlib.mli" ac_config_files="$ac_config_files stdcompat__string.mli" ac_config_files="$ac_config_files stdcompat__stringLabels.mli" ac_config_files="$ac_config_files stdcompat__sys.mli" ac_config_files="$ac_config_files stdcompat__uchar.mli" ac_config_files="$ac_config_files stdcompat__weak.mli" ac_config_files="$ac_config_files stdcompat__in_channel.mli" ac_config_files="$ac_config_files stdcompat__out_channel.mli" ac_config_files="$ac_config_files stdcompat__unit.mli" ac_config_files="$ac_config_files stdcompat.mli" ac_config_files="$ac_config_files stdcompat.ml" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # 'ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* 'ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # 'set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # 'set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 printf "%s\n" "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 printf %s "checking that generated files are newer than configure... " >&6; } if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5 printf "%s\n" "done" >&6; } if test -n "$EXEEXT"; then am__EXEEXT_TRUE= am__EXEEXT_FALSE='#' else am__EXEEXT_TRUE='#' am__EXEEXT_FALSE= fi if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then as_fn_error $? "conditional \"AMDEP\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${OCAML_SUPPORTS_BYTECODE_TRUE}" && test -z "${OCAML_SUPPORTS_BYTECODE_FALSE}"; then as_fn_error $? "conditional \"OCAML_SUPPORTS_BYTECODE\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${OCAML_SUPPORTS_NATIVE_TRUE}" && test -z "${OCAML_SUPPORTS_NATIVE_FALSE}"; then as_fn_error $? "conditional \"OCAML_SUPPORTS_NATIVE\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${OCAML_SUPPORTS_SHARED_TRUE}" && test -z "${OCAML_SUPPORTS_SHARED_FALSE}"; then as_fn_error $? "conditional \"OCAML_SUPPORTS_SHARED\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${OCAML_SUPPORTS_NO_ALIAS_DEPS_TRUE}" && test -z "${OCAML_SUPPORTS_NO_ALIAS_DEPS_FALSE}"; then as_fn_error $? "conditional \"OCAML_SUPPORTS_NO_ALIAS_DEPS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${OCAML_SUPPORTS_BIN_ANNOT_TRUE}" && test -z "${OCAML_SUPPORTS_BIN_ANNOT_FALSE}"; then as_fn_error $? "conditional \"OCAML_SUPPORTS_BIN_ANNOT\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${OCAML_SUPPORTS_ALERT_TRUE}" && test -z "${OCAML_SUPPORTS_ALERT_FALSE}"; then as_fn_error $? "conditional \"OCAML_SUPPORTS_ALERT\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case e in #( e) case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac ;; esac fi # Reset variables that may have inherited troublesome values from # the environment. # IFS needs to be set, to space, tab, and newline, in precisely that order. # (If _AS_PATH_WALK were called with IFS unset, it would have the # side effect of setting IFS to empty, thus disabling word splitting.) # Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl IFS=" "" $as_nl" PS1='$ ' PS2='> ' PS4='+ ' # Ensure predictable behavior from utilities with locale-dependent output. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # We cannot yet rely on "unset" to work, but we need these variables # to be unset--not just set to an empty or harmless value--now, to # avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct # also avoids known problems related to "unset" and subshell syntax # in other old shells (e.g. bash 2.01 and pdksh 5.2.14). for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH do eval test \${$as_var+y} \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done # Ensure that fds 0, 1, and 2 are open. if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS case $as_dir in #((( '') as_dir=./ ;; */) ;; *) as_dir=$as_dir/ ;; esac test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as 'sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null then : eval 'as_fn_append () { eval $1+=\$2 }' else case e in #( e) as_fn_append () { eval $1=\$$1\$2 } ;; esac fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null then : eval 'as_fn_arith () { as_val=$(( $* )) }' else case e in #( e) as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } ;; esac fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits # Determine whether it's possible to make 'echo' print without a newline. # These variables are no longer used directly by Autoconf, but are AC_SUBSTed # for compatibility with existing Makefiles. ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac # For backward compatibility with old third-party macros, we provide # the shell variables $as_echo and $as_echo_n. New code should use # AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. as_echo='printf %s\n' as_echo_n='printf %s' rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable. # In both cases, we have to default to 'cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated # Sed expression to map a string onto a valid variable name. as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g" as_tr_sh="eval sed '$as_sed_sh'" # deprecated exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by stdcompat $as_me 19, which was generated by GNU Autoconf 2.72. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" config_commands="$ac_config_commands" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ '$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Configuration commands: $config_commands Report bugs to . stdcompat home page: ." _ACEOF ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"` ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ stdcompat config.status 19 configured by $0, generated by GNU Autoconf 2.72, with options \\"\$ac_cs_config\\" Copyright (C) 2023 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' INSTALL='$INSTALL' MKDIR_P='$MKDIR_P' AWK='$AWK' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) printf "%s\n" "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) printf "%s\n" "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: '$1' Try '$0 --help' for more information.";; --help | --hel | -h ) printf "%s\n" "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: '$1' Try '$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX printf "%s\n" "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # # INIT-COMMANDS # AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "META") CONFIG_FILES="$CONFIG_FILES META" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "stdcompat__hashtbl_ext.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__hashtbl_ext.mli" ;; "stdcompat__hashtbl_ext.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__hashtbl_ext.ml" ;; "stdcompat__init.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__init.mli" ;; "stdcompat__init.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__init.ml:stdcompat__init.mli.in" ;; "stdcompat__root.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__root.mli" ;; "stdcompat__root.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__root.ml" ;; "stdcompat__tools.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__tools.mli" ;; "stdcompat__tools.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__tools.ml" ;; "stdcompat__native.ml_byte") CONFIG_FILES="$CONFIG_FILES stdcompat__native.ml_byte" ;; "stdcompat__native.ml_native") CONFIG_FILES="$CONFIG_FILES stdcompat__native.ml_native" ;; "stdcompat_tests.ml") CONFIG_FILES="$CONFIG_FILES stdcompat_tests.ml" ;; "stdcompat.h") CONFIG_FILES="$CONFIG_FILES stdcompat.h" ;; "stdcompat__stubs.c") CONFIG_FILES="$CONFIG_FILES stdcompat__stubs.c" ;; "stdcompat__pervasives_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__pervasives_s.mli" ;; "stdcompat__arg_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__arg_s.mli" ;; "stdcompat__array_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__array_s.mli" ;; "stdcompat__arrayLabels_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__arrayLabels_s.mli" ;; "stdcompat__atomic_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__atomic_s.mli" ;; "stdcompat__bool_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__bool_s.mli" ;; "stdcompat__buffer_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__buffer_s.mli" ;; "stdcompat__bytes_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__bytes_s.mli" ;; "stdcompat__bytesLabels_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__bytesLabels_s.mli" ;; "stdcompat__char_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__char_s.mli" ;; "stdcompat__digest_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__digest_s.mli" ;; "stdcompat__domain_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__domain_s.mli" ;; "stdcompat__either_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__either_s.mli" ;; "stdcompat__ephemeron_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__ephemeron_s.mli" ;; "stdcompat__filename_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__filename_s.mli" ;; "stdcompat__float_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__float_s.mli" ;; "stdcompat__format_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__format_s.mli" ;; "stdcompat__fun_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__fun_s.mli" ;; "stdcompat__hashtbl_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__hashtbl_s.mli" ;; "stdcompat__in_channel_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__in_channel_s.mli" ;; "stdcompat__int_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__int_s.mli" ;; "stdcompat__int32_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__int32_s.mli" ;; "stdcompat__int64_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__int64_s.mli" ;; "stdcompat__lazy_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__lazy_s.mli" ;; "stdcompat__lexing_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__lexing_s.mli" ;; "stdcompat__list_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__list_s.mli" ;; "stdcompat__listLabels_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__listLabels_s.mli" ;; "stdcompat__map_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__map_s.mli" ;; "stdcompat__moreLabels_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__moreLabels_s.mli" ;; "stdcompat__nativeint_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__nativeint_s.mli" ;; "stdcompat__option_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__option_s.mli" ;; "stdcompat__out_channel_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__out_channel_s.mli" ;; "stdcompat__printexc_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__printexc_s.mli" ;; "stdcompat__printf_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__printf_s.mli" ;; "stdcompat__queue_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__queue_s.mli" ;; "stdcompat__random_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__random_s.mli" ;; "stdcompat__result_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__result_s.mli" ;; "stdcompat__seq_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__seq_s.mli" ;; "stdcompat__set_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__set_s.mli" ;; "stdcompat__stack_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__stack_s.mli" ;; "stdcompat__string_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__string_s.mli" ;; "stdcompat__stringLabels_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__stringLabels_s.mli" ;; "stdcompat__sys_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__sys_s.mli" ;; "stdcompat__uchar_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__uchar_s.mli" ;; "stdcompat__weak_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__weak_s.mli" ;; "stdcompat__unit_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__unit_s.mli" ;; "stdcompat__stdlib_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__stdlib_s.mli" ;; "stdcompat__pervasives_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__pervasives_s.ml:stdcompat__pervasives_s.mli.in" ;; "stdcompat__arg_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__arg_s.ml:stdcompat__arg_s.mli.in" ;; "stdcompat__array_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__array_s.ml:stdcompat__array_s.mli.in" ;; "stdcompat__arrayLabels_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__arrayLabels_s.ml:stdcompat__arrayLabels_s.mli.in" ;; "stdcompat__atomic_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__atomic_s.ml:stdcompat__atomic_s.mli.in" ;; "stdcompat__bool_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__bool_s.ml:stdcompat__bool_s.mli.in" ;; "stdcompat__buffer_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__buffer_s.ml:stdcompat__buffer_s.mli.in" ;; "stdcompat__bytes_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__bytes_s.ml:stdcompat__bytes_s.mli.in" ;; "stdcompat__bytesLabels_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__bytesLabels_s.ml:stdcompat__bytesLabels_s.mli.in" ;; "stdcompat__char_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__char_s.ml:stdcompat__char_s.mli.in" ;; "stdcompat__digest_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__digest_s.ml:stdcompat__digest_s.mli.in" ;; "stdcompat__domain_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__domain_s.ml:stdcompat__domain_s.mli.in" ;; "stdcompat__either_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__either_s.ml:stdcompat__either_s.mli.in" ;; "stdcompat__ephemeron_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__ephemeron_s.ml:stdcompat__ephemeron_s.mli.in" ;; "stdcompat__filename_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__filename_s.ml:stdcompat__filename_s.mli.in" ;; "stdcompat__float_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__float_s.ml:stdcompat__float_s.mli.in" ;; "stdcompat__format_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__format_s.ml:stdcompat__format_s.mli.in" ;; "stdcompat__fun_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__fun_s.ml:stdcompat__fun_s.mli.in" ;; "stdcompat__hashtbl_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__hashtbl_s.ml:stdcompat__hashtbl_s.mli.in" ;; "stdcompat__int_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__int_s.ml:stdcompat__int_s.mli.in" ;; "stdcompat__int32_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__int32_s.ml:stdcompat__int32_s.mli.in" ;; "stdcompat__int64_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__int64_s.ml:stdcompat__int64_s.mli.in" ;; "stdcompat__lazy_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__lazy_s.ml:stdcompat__lazy_s.mli.in" ;; "stdcompat__lexing_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__lexing_s.ml:stdcompat__lexing_s.mli.in" ;; "stdcompat__list_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__list_s.ml:stdcompat__list_s.mli.in" ;; "stdcompat__listLabels_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__listLabels_s.ml:stdcompat__listLabels_s.mli.in" ;; "stdcompat__map_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__map_s.ml:stdcompat__map_s.mli.in" ;; "stdcompat__moreLabels_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__moreLabels_s.ml:stdcompat__moreLabels_s.mli.in" ;; "stdcompat__nativeint_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__nativeint_s.ml:stdcompat__nativeint_s.mli.in" ;; "stdcompat__option_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__option_s.ml:stdcompat__option_s.mli.in" ;; "stdcompat__printexc_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__printexc_s.ml:stdcompat__printexc_s.mli.in" ;; "stdcompat__printf_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__printf_s.ml:stdcompat__printf_s.mli.in" ;; "stdcompat__queue_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__queue_s.ml:stdcompat__queue_s.mli.in" ;; "stdcompat__random_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__random_s.ml:stdcompat__random_s.mli.in" ;; "stdcompat__result_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__result_s.ml:stdcompat__result_s.mli.in" ;; "stdcompat__seq_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__seq_s.ml:stdcompat__seq_s.mli.in" ;; "stdcompat__set_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__set_s.ml:stdcompat__set_s.mli.in" ;; "stdcompat__stack_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__stack_s.ml:stdcompat__stack_s.mli.in" ;; "stdcompat__stdlib_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__stdlib_s.ml:stdcompat__stdlib_s.mli.in" ;; "stdcompat__string_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__string_s.ml:stdcompat__string_s.mli.in" ;; "stdcompat__stringLabels_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__stringLabels_s.ml:stdcompat__stringLabels_s.mli.in" ;; "stdcompat__sys_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__sys_s.ml:stdcompat__sys_s.mli.in" ;; "stdcompat__uchar_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__uchar_s.ml:stdcompat__uchar_s.mli.in" ;; "stdcompat__weak_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__weak_s.ml:stdcompat__weak_s.mli.in" ;; "stdcompat__in_channel_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__in_channel_s.ml:stdcompat__in_channel_s.mli.in" ;; "stdcompat__out_channel_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__out_channel_s.ml:stdcompat__out_channel_s.mli.in" ;; "stdcompat__unit_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__unit_s.ml:stdcompat__unit_s.mli.in" ;; "stdcompat__pervasives.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__pervasives.ml" ;; "stdcompat__arg.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__arg.ml" ;; "stdcompat__array.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__array.ml" ;; "stdcompat__arrayLabels.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__arrayLabels.ml" ;; "stdcompat__atomic.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__atomic.ml" ;; "stdcompat__bool.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__bool.ml" ;; "stdcompat__buffer.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__buffer.ml" ;; "stdcompat__bytes.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__bytes.ml" ;; "stdcompat__bytesLabels.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__bytesLabels.ml" ;; "stdcompat__char.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__char.ml" ;; "stdcompat__digest.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__digest.ml" ;; "stdcompat__domain.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__domain.ml" ;; "stdcompat__either.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__either.ml" ;; "stdcompat__ephemeron.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__ephemeron.ml" ;; "stdcompat__filename.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__filename.ml" ;; "stdcompat__float.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__float.ml" ;; "stdcompat__format.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__format.ml" ;; "stdcompat__fun.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__fun.ml" ;; "stdcompat__hashtbl.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__hashtbl.ml" ;; "stdcompat__int.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__int.ml" ;; "stdcompat__int32.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__int32.ml" ;; "stdcompat__int64.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__int64.ml" ;; "stdcompat__lazy.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__lazy.ml" ;; "stdcompat__lexing.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__lexing.ml" ;; "stdcompat__list.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__list.ml" ;; "stdcompat__listLabels.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__listLabels.ml" ;; "stdcompat__map.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__map.ml" ;; "stdcompat__moreLabels.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__moreLabels.ml" ;; "stdcompat__nativeint.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__nativeint.ml" ;; "stdcompat__option.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__option.ml" ;; "stdcompat__printexc.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__printexc.ml" ;; "stdcompat__printf.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__printf.ml" ;; "stdcompat__queue.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__queue.ml" ;; "stdcompat__random.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__random.ml" ;; "stdcompat__result.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__result.ml" ;; "stdcompat__seq.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__seq.ml" ;; "stdcompat__set.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__set.ml" ;; "stdcompat__stack.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__stack.ml" ;; "stdcompat__stdlib.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__stdlib.ml" ;; "stdcompat__string.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__string.ml" ;; "stdcompat__stringLabels.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__stringLabels.ml" ;; "stdcompat__sys.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__sys.ml" ;; "stdcompat__uchar.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__uchar.ml" ;; "stdcompat__weak.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__weak.ml" ;; "stdcompat__in_channel.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__in_channel.ml" ;; "stdcompat__out_channel.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__out_channel.ml" ;; "stdcompat__unit.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__unit.ml" ;; "stdcompat__pervasives.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__pervasives.mli" ;; "stdcompat__arg.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__arg.mli" ;; "stdcompat__array.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__array.mli" ;; "stdcompat__arrayLabels.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__arrayLabels.mli" ;; "stdcompat__atomic.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__atomic.mli" ;; "stdcompat__bool.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__bool.mli" ;; "stdcompat__buffer.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__buffer.mli" ;; "stdcompat__bytes.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__bytes.mli" ;; "stdcompat__bytesLabels.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__bytesLabels.mli" ;; "stdcompat__char.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__char.mli" ;; "stdcompat__digest.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__digest.mli" ;; "stdcompat__domain.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__domain.mli" ;; "stdcompat__either.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__either.mli" ;; "stdcompat__ephemeron.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__ephemeron.mli" ;; "stdcompat__filename.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__filename.mli" ;; "stdcompat__float.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__float.mli" ;; "stdcompat__format.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__format.mli" ;; "stdcompat__fun.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__fun.mli" ;; "stdcompat__hashtbl.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__hashtbl.mli" ;; "stdcompat__int.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__int.mli" ;; "stdcompat__int32.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__int32.mli" ;; "stdcompat__int64.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__int64.mli" ;; "stdcompat__lazy.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__lazy.mli" ;; "stdcompat__lexing.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__lexing.mli" ;; "stdcompat__list.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__list.mli" ;; "stdcompat__listLabels.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__listLabels.mli" ;; "stdcompat__map.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__map.mli" ;; "stdcompat__moreLabels.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__moreLabels.mli" ;; "stdcompat__nativeint.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__nativeint.mli" ;; "stdcompat__option.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__option.mli" ;; "stdcompat__printexc.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__printexc.mli" ;; "stdcompat__printf.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__printf.mli" ;; "stdcompat__queue.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__queue.mli" ;; "stdcompat__random.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__random.mli" ;; "stdcompat__result.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__result.mli" ;; "stdcompat__seq.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__seq.mli" ;; "stdcompat__set.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__set.mli" ;; "stdcompat__stack.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__stack.mli" ;; "stdcompat__stdlib.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__stdlib.mli" ;; "stdcompat__string.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__string.mli" ;; "stdcompat__stringLabels.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__stringLabels.mli" ;; "stdcompat__sys.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__sys.mli" ;; "stdcompat__uchar.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__uchar.mli" ;; "stdcompat__weak.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__weak.mli" ;; "stdcompat__in_channel.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__in_channel.mli" ;; "stdcompat__out_channel.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__out_channel.mli" ;; "stdcompat__unit.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__unit.mli" ;; "stdcompat.mli") CONFIG_FILES="$CONFIG_FILES stdcompat.mli" ;; "stdcompat.ml") CONFIG_FILES="$CONFIG_FILES stdcompat.ml" ;; *) as_fn_error $? "invalid argument: '$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to '$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with './config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with './config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script 'defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #undef with comments. This is necessary, for example, # in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag '$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain ':'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is 'configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 printf "%s\n" "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`printf "%s\n" "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\\/$]* | ?:[\\/]* ) ;; */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when '$srcdir' = '.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&5 printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { printf "%s\n" "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 printf "%s\n" "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else printf "%s\n" "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi # Compute "$ac_file"'s index in $config_headers. _am_arg="$ac_file" _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || $as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$_am_arg" : 'X\(//\)[^/]' \| \ X"$_am_arg" : 'X\(//\)$' \| \ X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$_am_arg" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'`/stamp-h$_am_stamp_count ;; :C) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 printf "%s\n" "$as_me: executing $ac_file commands" >&6;} ;; esac case $ac_file$ac_mode in "depfiles":C) test x"$AMDEP_TRUE" != x"" || { # Older Autoconf quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. # TODO: see whether this extra hack can be removed once we start # requiring Autoconf 2.70 or later. case $CONFIG_FILES in #( *\'*) : eval set x "$CONFIG_FILES" ;; #( *) : set x $CONFIG_FILES ;; #( *) : ;; esac shift # Used to flag and report bootstrapping failures. am_rc=0 for am_mf do # Strip MF so we end up with the name of the file. am_mf=`printf "%s\n" "$am_mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile which includes # dependency-tracking related rules and includes. # Grep'ing the whole file directly is not great: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \ || continue am_dirpart=`$as_dirname -- "$am_mf" || $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$am_mf" : 'X\(//\)[^/]' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X"$am_mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` am_filepart=`$as_basename -- "$am_mf" || $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || printf "%s\n" X/"$am_mf" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` { echo "$as_me:$LINENO: cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles" >&5 (cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } || am_rc=$? done if test $am_rc -ne 0; then { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "Something went wrong bootstrapping makefile fragments for automatic dependency tracking. If GNU make was not used, consider re-running the configure script with MAKE=\"gmake\" (or whatever is necessary). You can also try re-running configure with the '--disable-dependency-tracking' option to at least be able to build the package (albeit without support for automatic dependency tracking). See 'config.log' for more details" "$LINENO" 5; } fi { am_dirpart=; unset am_dirpart;} { am_filepart=; unset am_filepart;} { am_mf=; unset am_mf;} { am_rc=; unset am_rc;} rm -f conftest-deps.mk } ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: OCaml version is $OCAMLVERSION" >&5 printf "%s\n" "$as_me: OCaml version is $OCAMLVERSION" >&6;} if test "x$enable_magic" = "xno" then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Only pure redefinitions will be used (--disable-magic: no use of Obj.magic)." >&5 printf "%s\n" "$as_me: Only pure redefinitions will be used (--disable-magic: no use of Obj.magic)." >&6;} else case e in #( e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Obj.magic will be used in redefinition when possible (add --disable-magic for pure redefinitions)." >&5 printf "%s\n" "$as_me: Obj.magic will be used in redefinition when possible (add --disable-magic for pure redefinitions)." >&6;} ;; esac fi ocaml-stdcompat-20~git20240529/configure.ac000066400000000000000000000447111463722102200204120ustar00rootroot00000000000000AC_INIT([[stdcompat]], m4_esyscmd([tr -d '\n' /dev/null 2>&1], [AC_MSG_RESULT([yes]) AC_MSG_CHECKING([if package $2 is usable]) echo "module M = $3" > configure_test.ml AS_IF([$OCAMLFIND c -package $2 configure_test.ml -o configure_test.out >/dev/null 2>&1], [rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out AC_MSG_RESULT([yes]) AC_SUBST([$1], [$2])], [rm -f configure_test.ml configure_test.cmo configure_test.cmi configure_test.out AC_MSG_RESULT([no]) AC_SUBST([$1], [])])], [AC_MSG_RESULT([no]) AC_SUBST([$1], [])])]) AC_CHECK_TOOL([OCAML], [ocaml], []) AC_CHECK_TOOL([OCAMLC], [ocamlc.opt], []) AS_IF([test "x$OCAMLC" = "x"], [AC_CHECK_TOOL([OCAMLC], [ocamlc], [])]) # ocamlc --version is not supported by OCaml <4.03 # \($\|\r\) is not supported by Mac OS sed AC_MSG_CHECKING([OCaml version]) AC_SUBST([OCAMLVERSION], [[`$OCAMLC -v | sed -n 's/^.*version \(.*\)$/\1/p' | sed 's/\r//'`]]) AC_MSG_RESULT([$OCAMLVERSION]) AC_SUBST([OCAML_VERSION_MAJOR], [[`echo $OCAMLVERSION | cut -d '.' -f 1`]]) AC_SUBST([OCAML_VERSION_MINOR], [[`echo $OCAMLVERSION | cut -d '.' -f 2`]]) AC_SUBST([OCAML_VERSION_PATCH_AND_EXTRA], [[`echo $OCAMLVERSION | cut -d '.' -f 3`]]) AS_IF([test "x$OCAML_VERSION_PATCH_AND_EXTRA" = "x"], [AC_SUBST([OCAML_VERSION_PATCHLEVEL], [[0]]) AC_SUBST([OCAML_RELEASE_EXTRA_PREFIX_CHAR], [[]])], [AC_SUBST([OCAML_VERSION_PATCHLEVEL], [[`echo $OCAML_VERSION_PATCH_AND_EXTRA | cut -c 1`]]) AC_SUBST([OCAML_RELEASE_EXTRA_PREFIX_CHAR], [[`echo $OCAML_VERSION_PATCH_AND_EXTRA | cut -c 2`]])]) AS_IF([test "x$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "x"], [AC_SUBST([OCAML_RELEASE_EXTRA], [[None]])], [AS_IF([test "$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "+"], [AC_SUBST([OCAML_RELEASE_EXTRA_PREFIX], [[Plus]])], [AC_SUBST([OCAML_RELEASE_EXTRA_PREFIX], [[Tilde]])]) AC_SUBST([OCAML_RELEASE_EXTRA], [["Some ($OCAML_RELEASE_EXTRA_PREFIX, \"`echo $OCAML_VERSION_PATCH_AND_EXTRA | cut -c 3-`\")"]])]) AS_IF([test "$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "~"], [AC_SUBST([OCAML_DEVELOPMENT_VERSION], [[true]])], [AS_IF([test "$OCAML_RELEASE_EXTRA_PREFIX_CHAR" = "+"], [AS_IF([echo $OCAMLVERSION | grep trunk], [AC_SUBST([OCAML_DEVELOPMENT_VERSION], [[true]])], [AC_SUBST([OCAML_DEVELOPMENT_VERSION], [[false]])])], [AC_SUBST([OCAML_DEVELOPMENT_VERSION], [[false]])])]) AC_CHECK_TOOL([OCAMLFIND], [ocamlfind], []) AS_IF([test "x$OCAMLFIND" = "x"], [AC_CHECK_TOOL([OCAMLOPT], [ocamlopt.opt], []) AS_IF([test "x$OCAMLOPT" = "x"], [AC_CHECK_TOOL([OCAMLOPT], [ocamlopt], [])]) AC_CHECK_TOOL([OCAMLDOC], [ocamldoc.opt], []) AS_IF([test "x$OCAMLDOC" = "x"], [AC_CHECK_TOOL([OCAMLDOC], [ocamldoc], [])]) AC_CHECK_TOOL([OCAMLDEP], [ocamldep.opt], []) AS_IF([test "x$OCAMLDEP" = "x"], [AC_CHECK_TOOL([OCAMLDEP], [ocamldep], [])]) AC_CHECK_TOOL([OCAMLMKLIB], [ocamlmklib.opt], []) AS_IF([test "x$OCAMLMKLIB" = "x"], [AC_CHECK_TOOL([OCAMLMKLIB], [ocamlmklib], [])]) AC_SUBST([RESULT_PKG], []) AC_SUBST([SEQ_PKG], []) AC_SUBST([UCHAR_PKG], [])], [AC_SUBST([OCAMLC], [["$OCAMLFIND ocamlc"]]) AC_SUBST([OCAMLOPT], [["$OCAMLFIND ocamlopt"]]) AC_SUBST([OCAMLDOC], [["$OCAMLFIND ocamldoc"]]) AC_SUBST([OCAMLDEP], [["$OCAMLFIND ocamldep"]]) AC_SUBST([OCAMLMKLIB], [["$OCAMLFIND ocamlmklib"]]) AC_OCAMLFIND_PKG([RESULT_PKG], [result], [Result]) AC_OCAMLFIND_PKG([SEQ_PKG], [seq], [Seq]) AC_OCAMLFIND_PKG([UCHAR_PKG], [uchar], [Uchar])]) AS_IF([test "x$OCAMLOPT" = "x"], [AS_IF([test "x$OCAMLC" = "x"], [AC_MSG_ERROR([[No OCaml compiler available]])], [AC_SUBST([OCAMLBEST], [["$OCAMLC"]]) AC_SUBST([CMAX], [["cma"]])])], [AC_SUBST([OCAMLBEST], [["$OCAMLOPT"]]) AC_SUBST([CMAX], [["cmxa"]])]) AS_IF([test "x$OCAMLDEP" = "x"], [AC_MSG_ERROR([[No ocamldep available]])]) AC_CONFIG_HEADERS([config.h]) AC_C_BIGENDIAN( [AC_SUBST([BIG_ENDIAN], [[true]])], [AC_SUBST([BIG_ENDIAN], [[false]])], [AC_MSG_ERROR([[Unknown endianness]])]) AC_MSG_CHECKING([OCaml target OS type]) AS_IF([test `printf "$OCAMLVERSION\n3.12.0" | sort | head -n1` = 3.12.0], [AC_SUBST([target_os_type], [[`$OCAMLBEST -config | sed -n 's/^os_type: \(.*\)$/\1/p' | sed 's/\r//'`]])], [AC_SUBST([target_os_type], [[`echo 'Sys.os_type;;' | $OCAML | sed -n 's/^\# - : string = "\(.*\)"$/\1/p'`]])]) AC_MSG_RESULT([$target_os_type]) AC_MSG_CHECKING([for flambda2]) AS_IF([test "$OCAML_VERSION_MAJOR" -ge 4], [AC_SUBST([OCAML_FLAMBDA2], [`$OCAMLBEST -config | sed -n 's/^flambda2: \(.*\)$/\1/p' | sed 's/\r//'`]) AS_IF([test "x$OCAML_FLAMBDA2" = "x"], AC_SUBST([OCAML_FLAMBDA2], [[false]]))], [AC_SUBST([OCAML_FLAMBDA2], [[false]])]) AC_MSG_RESULT([$OCAML_FLAMBDA2]) AC_ARG_ENABLE([magic], [AS_HELP_STRING([--enable-magic], [[use Obj.magic in redefinitions when possible (default)]]), AS_HELP_STRING([--disable-magic], [[use only pure redefinitions (without Obj.magic)]])], [], [AC_SUBST([enable_magic], [yes])]) AC_DEFUN([AC_DISABLE_BLOCK], [AC_SUBST([BEGIN_$1], [['(*']]) AC_SUBST([END_$1], [['*)']]) AC_SUBST([C_BEGIN_$1], [['#if 0']]) AC_SUBST([C_END_$1], [['#endif']])]) AC_DEFUN([AC_ENABLE_BLOCK], [AC_SUBST([BEGIN_$1], []) AC_SUBST([END_$1], []) AC_SUBST([C_BEGIN_$1], []) AC_SUBST([C_END_$1], [])]) AC_DEFUN([AC_WITH_BLOCK], [AC_ENABLE_BLOCK([WITH_$1]) AC_DISABLE_BLOCK([WITHOUT_$1])]) AC_DEFUN([AC_WITHOUT_BLOCK], [AC_DISABLE_BLOCK([WITH_$1]) AC_ENABLE_BLOCK([WITHOUT_$1])]) AC_DEFUN([AC_WITH_BLOCK_PKG], [AS_IF([test "x$$1_PKG" = "x"], [AC_WITHOUT_BLOCK($1_PKG)], [AC_WITH_BLOCK($1_PKG)])]) AC_DEFUN([AC_WITH_OCAML_VERSION], [AS_IF([test `printf "$OCAMLVERSION\n$2" | sort | head -n1` = $2], [AC_ENABLE_BLOCK([FROM_$1]) AC_DISABLE_BLOCK([BEFORE_$1])], [AC_DISABLE_BLOCK([FROM_$1]) AC_ENABLE_BLOCK([BEFORE_$1])])]) AS_IF([test "x$enable_magic" = "xno"], [AC_WITHOUT_BLOCK([MAGIC])], [AC_WITH_BLOCK([MAGIC])]) AC_WITH_BLOCK_PKG([RESULT]) AC_WITH_BLOCK_PKG([SEQ]) AC_WITH_BLOCK_PKG([UCHAR]) AC_WITH_OCAML_VERSION([3_07_0], [3.07]) AC_WITH_OCAML_VERSION([3_08_0], [3.08.0]) AC_WITH_OCAML_VERSION([3_09_0], [3.09.0]) AC_WITH_OCAML_VERSION([3_10_0], [3.10.0]) AC_WITH_OCAML_VERSION([3_11_0], [3.11.0]) AC_WITH_OCAML_VERSION([3_12_0], [3.12.0]) AC_WITH_OCAML_VERSION([4_00_0], [4.00.0]) AC_WITH_OCAML_VERSION([4_01_0], [4.01.0]) AC_WITH_OCAML_VERSION([4_02_0], [4.02.0]) AC_WITH_OCAML_VERSION([4_03_0], [4.03.0]) AC_WITH_OCAML_VERSION([4_04_0], [4.04.0]) AC_WITH_OCAML_VERSION([4_05_0], [4.05.0]) AC_WITH_OCAML_VERSION([4_06_0], [4.06.0]) AC_WITH_OCAML_VERSION([4_07_0], [4.07.0]) AC_WITH_OCAML_VERSION([4_07_1], [4.07.1]) AC_WITH_OCAML_VERSION([4_08_0], [4.08.0]) AC_WITH_OCAML_VERSION([4_09_0], [4.09.0]) AC_WITH_OCAML_VERSION([4_10_0], [4.10.0]) AC_WITH_OCAML_VERSION([4_11_0], [4.11.0]) AC_WITH_OCAML_VERSION([4_12_0], [4.12.0]) AC_WITH_OCAML_VERSION([4_13_0], [4.13.0]) AC_WITH_OCAML_VERSION([4_14_0], [4.14.0]) AC_WITH_OCAML_VERSION([5_0_0], [5.0.0]) AC_WITH_OCAML_VERSION([5_1_0], [5.1.0]) AC_WITH_OCAML_VERSION([5_2_0], [5.2.0]) AS_IF([test "x$target_os_type" = "xWin32"], [AC_WITH_BLOCK([WIN32])], [AC_WITHOUT_BLOCK([WIN32])]) AS_IF([test "x$target_os_type" = "xCygwin"], [AC_WITH_BLOCK([CYGWIN])], [AC_WITHOUT_BLOCK([CYGWIN])]) AS_IF([test "x$target_os_type" = "xUnix"], [AC_WITH_BLOCK([UNIX])], [AC_WITHOUT_BLOCK([UNIX])]) AS_IF([test "x$OCAML_FLAMBDA2" = "xtrue"], [AC_WITH_BLOCK([FLAMBDA2])], [AC_WITHOUT_BLOCK([FLAMBDA2])]) AM_CONDITIONAL(OCAML_SUPPORTS_BYTECODE, [test "x$OCAMLC" != "x"]) AM_CONDITIONAL(OCAML_SUPPORTS_NATIVE, [test "x$OCAMLOPT" != "x"]) AM_CONDITIONAL(OCAML_SUPPORTS_SHARED, [test `printf "$OCAMLVERSION\n3.11.1" | sort | head -n1` = 3.11.1]) AS_IF([test "x$OCAML_SUPPORTS_SHARED_TRUE" = "x"], [AC_SUBST([SHARED_LIBS], [["stdcompat.cmxs"]])], [AC_SUBST([SHARED_LIBS], [[""]])]) AM_CONDITIONAL(OCAML_SUPPORTS_NO_ALIAS_DEPS, [test `printf "$OCAMLVERSION\n4.02.0" | sort | head -n1` = 4.02.0]) AM_CONDITIONAL(OCAML_SUPPORTS_BIN_ANNOT, [test `printf "$OCAMLVERSION\n4.00.0" | sort | head -n1` = 4.00.0]) AM_CONDITIONAL(OCAML_SUPPORTS_ALERT, [test `printf "$OCAMLVERSION\n4.08.0" | sort | head -n1` = 4.08.0]) AC_SUBST([INCLUDE_DEPEND],[[' ifneq ($(MAKECMDGOALS),clean) ifneq ($(MAKECMDGOALS),distclean) include .depend endif endif ']]) AC_CONFIG_FILES([META Makefile]) AC_CONFIG_FILES([stdcompat__hashtbl_ext.mli]) AC_CONFIG_FILES([stdcompat__hashtbl_ext.ml]) AC_CONFIG_FILES([stdcompat__init.mli]) AC_CONFIG_FILES([stdcompat__init.ml:stdcompat__init.mli.in]) AC_CONFIG_FILES([stdcompat__root.mli]) AC_CONFIG_FILES([stdcompat__root.ml]) AC_CONFIG_FILES([stdcompat__tools.mli]) AC_CONFIG_FILES([stdcompat__tools.ml]) AC_CONFIG_FILES([stdcompat__native.ml_byte]) AC_CONFIG_FILES([stdcompat__native.ml_native]) AC_CONFIG_FILES([stdcompat_tests.ml]) AC_CONFIG_FILES([stdcompat.h]) AC_CONFIG_FILES([stdcompat__stubs.c]) AC_CONFIG_FILES([stdcompat__pervasives_s.mli]) AC_CONFIG_FILES([stdcompat__arg_s.mli]) AC_CONFIG_FILES([stdcompat__array_s.mli]) AC_CONFIG_FILES([stdcompat__arrayLabels_s.mli]) AC_CONFIG_FILES([stdcompat__atomic_s.mli]) AC_CONFIG_FILES([stdcompat__bool_s.mli]) AC_CONFIG_FILES([stdcompat__buffer_s.mli]) AC_CONFIG_FILES([stdcompat__bytes_s.mli]) AC_CONFIG_FILES([stdcompat__bytesLabels_s.mli]) AC_CONFIG_FILES([stdcompat__char_s.mli]) AC_CONFIG_FILES([stdcompat__digest_s.mli]) AC_CONFIG_FILES([stdcompat__domain_s.mli]) AC_CONFIG_FILES([stdcompat__either_s.mli]) AC_CONFIG_FILES([stdcompat__ephemeron_s.mli]) AC_CONFIG_FILES([stdcompat__filename_s.mli]) AC_CONFIG_FILES([stdcompat__float_s.mli]) AC_CONFIG_FILES([stdcompat__format_s.mli]) AC_CONFIG_FILES([stdcompat__fun_s.mli]) AC_CONFIG_FILES([stdcompat__hashtbl_s.mli]) AC_CONFIG_FILES([stdcompat__in_channel_s.mli]) AC_CONFIG_FILES([stdcompat__int_s.mli]) AC_CONFIG_FILES([stdcompat__int32_s.mli]) AC_CONFIG_FILES([stdcompat__int64_s.mli]) AC_CONFIG_FILES([stdcompat__lazy_s.mli]) AC_CONFIG_FILES([stdcompat__lexing_s.mli]) AC_CONFIG_FILES([stdcompat__list_s.mli]) AC_CONFIG_FILES([stdcompat__listLabels_s.mli]) AC_CONFIG_FILES([stdcompat__map_s.mli]) AC_CONFIG_FILES([stdcompat__moreLabels_s.mli]) AC_CONFIG_FILES([stdcompat__nativeint_s.mli]) AC_CONFIG_FILES([stdcompat__option_s.mli]) AC_CONFIG_FILES([stdcompat__out_channel_s.mli]) AC_CONFIG_FILES([stdcompat__printexc_s.mli]) AC_CONFIG_FILES([stdcompat__printf_s.mli]) AC_CONFIG_FILES([stdcompat__queue_s.mli]) AC_CONFIG_FILES([stdcompat__random_s.mli]) AC_CONFIG_FILES([stdcompat__result_s.mli]) AC_CONFIG_FILES([stdcompat__seq_s.mli]) AC_CONFIG_FILES([stdcompat__set_s.mli]) AC_CONFIG_FILES([stdcompat__stack_s.mli]) AC_CONFIG_FILES([stdcompat__string_s.mli]) AC_CONFIG_FILES([stdcompat__stringLabels_s.mli]) AC_CONFIG_FILES([stdcompat__sys_s.mli]) AC_CONFIG_FILES([stdcompat__uchar_s.mli]) AC_CONFIG_FILES([stdcompat__weak_s.mli]) AC_CONFIG_FILES([stdcompat__unit_s.mli]) AC_CONFIG_FILES([stdcompat__stdlib_s.mli]) AC_CONFIG_FILES([stdcompat__pervasives_s.ml:stdcompat__pervasives_s.mli.in]) AC_CONFIG_FILES([stdcompat__arg_s.ml:stdcompat__arg_s.mli.in]) AC_CONFIG_FILES([stdcompat__array_s.ml:stdcompat__array_s.mli.in]) AC_CONFIG_FILES([stdcompat__arrayLabels_s.ml:stdcompat__arrayLabels_s.mli.in]) AC_CONFIG_FILES([stdcompat__atomic_s.ml:stdcompat__atomic_s.mli.in]) AC_CONFIG_FILES([stdcompat__bool_s.ml:stdcompat__bool_s.mli.in]) AC_CONFIG_FILES([stdcompat__buffer_s.ml:stdcompat__buffer_s.mli.in]) AC_CONFIG_FILES([stdcompat__bytes_s.ml:stdcompat__bytes_s.mli.in]) AC_CONFIG_FILES([stdcompat__bytesLabels_s.ml:stdcompat__bytesLabels_s.mli.in]) AC_CONFIG_FILES([stdcompat__char_s.ml:stdcompat__char_s.mli.in]) AC_CONFIG_FILES([stdcompat__digest_s.ml:stdcompat__digest_s.mli.in]) AC_CONFIG_FILES([stdcompat__domain_s.ml:stdcompat__domain_s.mli.in]) AC_CONFIG_FILES([stdcompat__either_s.ml:stdcompat__either_s.mli.in]) AC_CONFIG_FILES([stdcompat__ephemeron_s.ml:stdcompat__ephemeron_s.mli.in]) AC_CONFIG_FILES([stdcompat__filename_s.ml:stdcompat__filename_s.mli.in]) AC_CONFIG_FILES([stdcompat__float_s.ml:stdcompat__float_s.mli.in]) AC_CONFIG_FILES([stdcompat__format_s.ml:stdcompat__format_s.mli.in]) AC_CONFIG_FILES([stdcompat__fun_s.ml:stdcompat__fun_s.mli.in]) AC_CONFIG_FILES([stdcompat__hashtbl_s.ml:stdcompat__hashtbl_s.mli.in]) AC_CONFIG_FILES([stdcompat__int_s.ml:stdcompat__int_s.mli.in]) AC_CONFIG_FILES([stdcompat__int32_s.ml:stdcompat__int32_s.mli.in]) AC_CONFIG_FILES([stdcompat__int64_s.ml:stdcompat__int64_s.mli.in]) AC_CONFIG_FILES([stdcompat__lazy_s.ml:stdcompat__lazy_s.mli.in]) AC_CONFIG_FILES([stdcompat__lexing_s.ml:stdcompat__lexing_s.mli.in]) AC_CONFIG_FILES([stdcompat__list_s.ml:stdcompat__list_s.mli.in]) AC_CONFIG_FILES([stdcompat__listLabels_s.ml:stdcompat__listLabels_s.mli.in]) AC_CONFIG_FILES([stdcompat__map_s.ml:stdcompat__map_s.mli.in]) AC_CONFIG_FILES([stdcompat__moreLabels_s.ml:stdcompat__moreLabels_s.mli.in]) AC_CONFIG_FILES([stdcompat__nativeint_s.ml:stdcompat__nativeint_s.mli.in]) AC_CONFIG_FILES([stdcompat__option_s.ml:stdcompat__option_s.mli.in]) AC_CONFIG_FILES([stdcompat__printexc_s.ml:stdcompat__printexc_s.mli.in]) AC_CONFIG_FILES([stdcompat__printf_s.ml:stdcompat__printf_s.mli.in]) AC_CONFIG_FILES([stdcompat__queue_s.ml:stdcompat__queue_s.mli.in]) AC_CONFIG_FILES([stdcompat__random_s.ml:stdcompat__random_s.mli.in]) AC_CONFIG_FILES([stdcompat__result_s.ml:stdcompat__result_s.mli.in]) AC_CONFIG_FILES([stdcompat__seq_s.ml:stdcompat__seq_s.mli.in]) AC_CONFIG_FILES([stdcompat__set_s.ml:stdcompat__set_s.mli.in]) AC_CONFIG_FILES([stdcompat__stack_s.ml:stdcompat__stack_s.mli.in]) AC_CONFIG_FILES([stdcompat__stdlib_s.ml:stdcompat__stdlib_s.mli.in]) AC_CONFIG_FILES([stdcompat__string_s.ml:stdcompat__string_s.mli.in]) AC_CONFIG_FILES([stdcompat__stringLabels_s.ml:stdcompat__stringLabels_s.mli.in]) AC_CONFIG_FILES([stdcompat__sys_s.ml:stdcompat__sys_s.mli.in]) AC_CONFIG_FILES([stdcompat__uchar_s.ml:stdcompat__uchar_s.mli.in]) AC_CONFIG_FILES([stdcompat__weak_s.ml:stdcompat__weak_s.mli.in]) AC_CONFIG_FILES([stdcompat__in_channel_s.ml:stdcompat__in_channel_s.mli.in]) AC_CONFIG_FILES([stdcompat__out_channel_s.ml:stdcompat__out_channel_s.mli.in]) AC_CONFIG_FILES([stdcompat__unit_s.ml:stdcompat__unit_s.mli.in]) AC_CONFIG_FILES([stdcompat__pervasives.ml]) AC_CONFIG_FILES([stdcompat__arg.ml]) AC_CONFIG_FILES([stdcompat__array.ml]) AC_CONFIG_FILES([stdcompat__arrayLabels.ml]) AC_CONFIG_FILES([stdcompat__atomic.ml]) AC_CONFIG_FILES([stdcompat__bool.ml]) AC_CONFIG_FILES([stdcompat__buffer.ml]) AC_CONFIG_FILES([stdcompat__bytes.ml]) AC_CONFIG_FILES([stdcompat__bytesLabels.ml]) AC_CONFIG_FILES([stdcompat__char.ml]) AC_CONFIG_FILES([stdcompat__digest.ml]) AC_CONFIG_FILES([stdcompat__domain.ml]) AC_CONFIG_FILES([stdcompat__either.ml]) AC_CONFIG_FILES([stdcompat__ephemeron.ml]) AC_CONFIG_FILES([stdcompat__filename.ml]) AC_CONFIG_FILES([stdcompat__float.ml]) AC_CONFIG_FILES([stdcompat__format.ml]) AC_CONFIG_FILES([stdcompat__fun.ml]) AC_CONFIG_FILES([stdcompat__hashtbl.ml]) AC_CONFIG_FILES([stdcompat__int.ml]) AC_CONFIG_FILES([stdcompat__int32.ml]) AC_CONFIG_FILES([stdcompat__int64.ml]) AC_CONFIG_FILES([stdcompat__lazy.ml]) AC_CONFIG_FILES([stdcompat__lexing.ml]) AC_CONFIG_FILES([stdcompat__list.ml]) AC_CONFIG_FILES([stdcompat__listLabels.ml]) AC_CONFIG_FILES([stdcompat__map.ml]) AC_CONFIG_FILES([stdcompat__moreLabels.ml]) AC_CONFIG_FILES([stdcompat__nativeint.ml]) AC_CONFIG_FILES([stdcompat__option.ml]) AC_CONFIG_FILES([stdcompat__printexc.ml]) AC_CONFIG_FILES([stdcompat__printf.ml]) AC_CONFIG_FILES([stdcompat__queue.ml]) AC_CONFIG_FILES([stdcompat__random.ml]) AC_CONFIG_FILES([stdcompat__result.ml]) AC_CONFIG_FILES([stdcompat__seq.ml]) AC_CONFIG_FILES([stdcompat__set.ml]) AC_CONFIG_FILES([stdcompat__stack.ml]) AC_CONFIG_FILES([stdcompat__stdlib.ml]) AC_CONFIG_FILES([stdcompat__string.ml]) AC_CONFIG_FILES([stdcompat__stringLabels.ml]) AC_CONFIG_FILES([stdcompat__sys.ml]) AC_CONFIG_FILES([stdcompat__uchar.ml]) AC_CONFIG_FILES([stdcompat__weak.ml]) AC_CONFIG_FILES([stdcompat__in_channel.ml]) AC_CONFIG_FILES([stdcompat__out_channel.ml]) AC_CONFIG_FILES([stdcompat__unit.ml]) AC_CONFIG_FILES([stdcompat__pervasives.mli]) AC_CONFIG_FILES([stdcompat__arg.mli]) AC_CONFIG_FILES([stdcompat__array.mli]) AC_CONFIG_FILES([stdcompat__arrayLabels.mli]) AC_CONFIG_FILES([stdcompat__atomic.mli]) AC_CONFIG_FILES([stdcompat__bool.mli]) AC_CONFIG_FILES([stdcompat__buffer.mli]) AC_CONFIG_FILES([stdcompat__bytes.mli]) AC_CONFIG_FILES([stdcompat__bytesLabels.mli]) AC_CONFIG_FILES([stdcompat__char.mli]) AC_CONFIG_FILES([stdcompat__digest.mli]) AC_CONFIG_FILES([stdcompat__domain.mli]) AC_CONFIG_FILES([stdcompat__either.mli]) AC_CONFIG_FILES([stdcompat__ephemeron.mli]) AC_CONFIG_FILES([stdcompat__filename.mli]) AC_CONFIG_FILES([stdcompat__float.mli]) AC_CONFIG_FILES([stdcompat__format.mli]) AC_CONFIG_FILES([stdcompat__fun.mli]) AC_CONFIG_FILES([stdcompat__hashtbl.mli]) AC_CONFIG_FILES([stdcompat__int.mli]) AC_CONFIG_FILES([stdcompat__int32.mli]) AC_CONFIG_FILES([stdcompat__int64.mli]) AC_CONFIG_FILES([stdcompat__lazy.mli]) AC_CONFIG_FILES([stdcompat__lexing.mli]) AC_CONFIG_FILES([stdcompat__list.mli]) AC_CONFIG_FILES([stdcompat__listLabels.mli]) AC_CONFIG_FILES([stdcompat__map.mli]) AC_CONFIG_FILES([stdcompat__moreLabels.mli]) AC_CONFIG_FILES([stdcompat__nativeint.mli]) AC_CONFIG_FILES([stdcompat__option.mli]) AC_CONFIG_FILES([stdcompat__printexc.mli]) AC_CONFIG_FILES([stdcompat__printf.mli]) AC_CONFIG_FILES([stdcompat__queue.mli]) AC_CONFIG_FILES([stdcompat__random.mli]) AC_CONFIG_FILES([stdcompat__result.mli]) AC_CONFIG_FILES([stdcompat__seq.mli]) AC_CONFIG_FILES([stdcompat__set.mli]) AC_CONFIG_FILES([stdcompat__stack.mli]) AC_CONFIG_FILES([stdcompat__stdlib.mli]) AC_CONFIG_FILES([stdcompat__string.mli]) AC_CONFIG_FILES([stdcompat__stringLabels.mli]) AC_CONFIG_FILES([stdcompat__sys.mli]) AC_CONFIG_FILES([stdcompat__uchar.mli]) AC_CONFIG_FILES([stdcompat__weak.mli]) AC_CONFIG_FILES([stdcompat__in_channel.mli]) AC_CONFIG_FILES([stdcompat__out_channel.mli]) AC_CONFIG_FILES([stdcompat__unit.mli]) AC_CONFIG_FILES([stdcompat.mli]) AC_CONFIG_FILES([stdcompat.ml]) AC_OUTPUT AC_MSG_NOTICE([OCaml version is $OCAMLVERSION]) AS_IF([test "x$enable_magic" = "xno"], [AC_MSG_NOTICE( [[Only pure redefinitions will be used ]] [[(--disable-magic: no use of Obj.magic).]])], [AC_MSG_NOTICE( [[Obj.magic will be used in redefinition when possible ]] [[(add --disable-magic for pure redefinitions).]])]) ocaml-stdcompat-20~git20240529/dune000066400000000000000000000276071463722102200170070ustar00rootroot00000000000000(library (name stdcompat) (public_name stdcompat) (wrapped false) (flags (:standard -nolabels -w -3)) (install_c_headers stdcompat) (foreign_stubs (language c) (names stdcompat__stubs)) (modules stdcompat__arg stdcompat__arg_s stdcompat__array stdcompat__arrayLabels stdcompat__arrayLabels_s stdcompat__array_s stdcompat__atomic stdcompat__atomic_s stdcompat__bool stdcompat__bool_s stdcompat__buffer stdcompat__buffer_s stdcompat__bytes stdcompat__bytesLabels stdcompat__bytesLabels_s stdcompat__bytes_s stdcompat__char stdcompat__char_s stdcompat__digest stdcompat__digest_s stdcompat__domain stdcompat__domain_s stdcompat__either stdcompat__either_s stdcompat__ephemeron stdcompat__ephemeron_s stdcompat__filename stdcompat__filename_s stdcompat__float stdcompat__float_s stdcompat__format stdcompat__format_s stdcompat__fun stdcompat__fun_s stdcompat__hashtbl stdcompat__hashtbl_ext stdcompat__hashtbl_s stdcompat__in_channel stdcompat__in_channel_s stdcompat__init stdcompat__int stdcompat__int32 stdcompat__int32_s stdcompat__int64 stdcompat__int64_s stdcompat__int_s stdcompat__lazy stdcompat__lazy_s stdcompat__lexing stdcompat__lexing_s stdcompat__list stdcompat__listLabels stdcompat__listLabels_s stdcompat__list_s stdcompat__map stdcompat__map_s stdcompat__moreLabels stdcompat__moreLabels_s stdcompat__native stdcompat__nativeint stdcompat__nativeint_s stdcompat__option stdcompat__option_s stdcompat__out_channel stdcompat__out_channel_s stdcompat__pervasives stdcompat__pervasives_s stdcompat__printexc stdcompat__printexc_s stdcompat__printf stdcompat__printf_s stdcompat__queue stdcompat__queue_s stdcompat__random stdcompat__random_s stdcompat__result stdcompat__result_s stdcompat__root stdcompat__seq stdcompat__seq_s stdcompat__set stdcompat__set_s stdcompat__stack stdcompat__stack_s stdcompat__stdlib stdcompat__stdlib_s stdcompat__string stdcompat__stringLabels stdcompat__stringLabels_s stdcompat__string_s stdcompat__sys stdcompat__sys_s stdcompat__tools stdcompat__uchar stdcompat__uchar_s stdcompat__unit stdcompat__unit_s stdcompat__weak stdcompat__weak_s stdcompat)) (executable (name stdcompat_tests) (modules stdcompat_tests) (libraries stdcompat)) (rule (copy stdcompat__native.ml_native stdcompat__native.ml)) (rule (copy stdcompat__init.mli.in stdcompat__init.ml.in)) (rule (targets configure Makefile.in) (mode promote) (deps Makefile.am VERSION configure.ac) (action (run %{bin:autoreconf} --force --install --verbose))) (rule (targets META Makefile stdcompat.h stdcompat__native.ml_byte stdcompat__native.ml_native stdcompat.ml stdcompat.mli stdcompat_tests.ml stdcompat__arg.ml stdcompat__arg.mli stdcompat__arg_s.ml stdcompat__arg_s.mli stdcompat__array.ml stdcompat__array.mli stdcompat__arrayLabels.ml stdcompat__arrayLabels.mli stdcompat__arrayLabels_s.ml stdcompat__arrayLabels_s.mli stdcompat__array_s.ml stdcompat__array_s.mli stdcompat__atomic.ml stdcompat__atomic.mli stdcompat__atomic_s.ml stdcompat__atomic_s.mli stdcompat__bool.ml stdcompat__bool.mli stdcompat__bool_s.ml stdcompat__bool_s.mli stdcompat__buffer.ml stdcompat__buffer.mli stdcompat__buffer_s.ml stdcompat__buffer_s.mli stdcompat__bytes.ml stdcompat__bytes.mli stdcompat__bytesLabels.ml stdcompat__bytesLabels.mli stdcompat__bytesLabels_s.ml stdcompat__bytesLabels_s.mli stdcompat__bytes_s.ml stdcompat__bytes_s.mli stdcompat__char.ml stdcompat__char.mli stdcompat__char_s.ml stdcompat__char_s.mli stdcompat__digest.ml stdcompat__digest.mli stdcompat__digest_s.ml stdcompat__digest_s.mli stdcompat__domain.ml stdcompat__domain.mli stdcompat__domain_s.ml stdcompat__domain_s.mli stdcompat__either.ml stdcompat__either.mli stdcompat__either_s.ml stdcompat__either_s.mli stdcompat__ephemeron.ml stdcompat__ephemeron.mli stdcompat__ephemeron_s.ml stdcompat__ephemeron_s.mli stdcompat__filename.ml stdcompat__filename.mli stdcompat__filename_s.ml stdcompat__filename_s.mli stdcompat__float.ml stdcompat__float.mli stdcompat__float_s.ml stdcompat__float_s.mli stdcompat__format.ml stdcompat__format.mli stdcompat__format_s.ml stdcompat__format_s.mli stdcompat__fun.ml stdcompat__fun.mli stdcompat__fun_s.ml stdcompat__fun_s.mli stdcompat__hashtbl.ml stdcompat__hashtbl.mli stdcompat__hashtbl_ext.ml stdcompat__hashtbl_ext.mli stdcompat__hashtbl_s.ml stdcompat__hashtbl_s.mli stdcompat__in_channel.ml stdcompat__in_channel.mli stdcompat__in_channel_s.ml stdcompat__in_channel_s.mli stdcompat__init.ml stdcompat__init.mli stdcompat__int.ml stdcompat__int.mli stdcompat__int32.ml stdcompat__int32.mli stdcompat__int32_s.ml stdcompat__int32_s.mli stdcompat__int64.ml stdcompat__int64.mli stdcompat__int64_s.ml stdcompat__int64_s.mli stdcompat__int_s.ml stdcompat__int_s.mli stdcompat__lazy.ml stdcompat__lazy.mli stdcompat__lazy_s.ml stdcompat__lazy_s.mli stdcompat__lexing.ml stdcompat__lexing.mli stdcompat__lexing_s.ml stdcompat__lexing_s.mli stdcompat__list.ml stdcompat__list.mli stdcompat__listLabels.ml stdcompat__listLabels.mli stdcompat__listLabels_s.ml stdcompat__listLabels_s.mli stdcompat__list_s.ml stdcompat__list_s.mli stdcompat__map.ml stdcompat__map.mli stdcompat__map_s.ml stdcompat__map_s.mli stdcompat__moreLabels.ml stdcompat__moreLabels.mli stdcompat__moreLabels_s.ml stdcompat__moreLabels_s.mli stdcompat__nativeint.ml stdcompat__nativeint.mli stdcompat__nativeint_s.ml stdcompat__nativeint_s.mli stdcompat__option.ml stdcompat__option.mli stdcompat__option_s.ml stdcompat__option_s.mli stdcompat__out_channel.ml stdcompat__out_channel.mli stdcompat__out_channel_s.ml stdcompat__out_channel_s.mli stdcompat__pervasives.ml stdcompat__pervasives.mli stdcompat__pervasives_s.ml stdcompat__pervasives_s.mli stdcompat__printexc.ml stdcompat__printexc.mli stdcompat__printexc_s.ml stdcompat__printexc_s.mli stdcompat__printf.ml stdcompat__printf.mli stdcompat__printf_s.ml stdcompat__printf_s.mli stdcompat__queue.ml stdcompat__queue.mli stdcompat__queue_s.ml stdcompat__queue_s.mli stdcompat__random.ml stdcompat__random.mli stdcompat__random_s.ml stdcompat__random_s.mli stdcompat__result.ml stdcompat__result.mli stdcompat__result_s.ml stdcompat__result_s.mli stdcompat__root.ml stdcompat__root.mli stdcompat__seq.ml stdcompat__seq.mli stdcompat__seq_s.ml stdcompat__seq_s.mli stdcompat__set.ml stdcompat__set.mli stdcompat__set_s.ml stdcompat__set_s.mli stdcompat__stack.ml stdcompat__stack.mli stdcompat__stack_s.ml stdcompat__stack_s.mli stdcompat__stdlib.ml stdcompat__stdlib.mli stdcompat__stdlib_s.ml stdcompat__stdlib_s.mli stdcompat__string.ml stdcompat__string.mli stdcompat__stringLabels.ml stdcompat__stringLabels.mli stdcompat__stringLabels_s.ml stdcompat__stringLabels_s.mli stdcompat__string_s.ml stdcompat__string_s.mli stdcompat__stubs.c stdcompat__sys.ml stdcompat__sys.mli stdcompat__sys_s.ml stdcompat__sys_s.mli stdcompat__tools.ml stdcompat__tools.mli stdcompat__uchar.ml stdcompat__uchar.mli stdcompat__uchar_s.ml stdcompat__uchar_s.mli stdcompat__unit.ml stdcompat__unit.mli stdcompat__unit_s.ml stdcompat__unit_s.mli stdcompat__weak.ml stdcompat__weak.mli stdcompat__weak_s.ml stdcompat__weak_s.mli) (deps (:configure configure) install-sh META.in Makefile.in config.h.in stdcompat.h.in stdcompat.ml.in stdcompat.mli.in stdcompat__arg.ml.in stdcompat__arg.mli.in stdcompat__arg_s.mli.in stdcompat__array.ml.in stdcompat__array.mli.in stdcompat__arrayLabels.ml.in stdcompat__arrayLabels.mli.in stdcompat__arrayLabels_s.mli.in stdcompat__array_s.mli.in stdcompat__atomic.ml.in stdcompat__atomic.mli.in stdcompat__atomic_s.mli.in stdcompat__bool.ml.in stdcompat__bool.mli.in stdcompat__bool_s.mli.in stdcompat__buffer.ml.in stdcompat__buffer.mli.in stdcompat__buffer_s.mli.in stdcompat__bytes.ml.in stdcompat__bytes.mli.in stdcompat__bytesLabels.ml.in stdcompat__bytesLabels.mli.in stdcompat__bytesLabels_s.mli.in stdcompat__bytes_s.mli.in stdcompat__char.ml.in stdcompat__char.mli.in stdcompat__char_s.mli.in stdcompat__digest.ml.in stdcompat__digest.mli.in stdcompat__digest_s.mli.in stdcompat__domain.ml.in stdcompat__domain.mli.in stdcompat__domain_s.mli.in stdcompat__either.ml.in stdcompat__either.mli.in stdcompat__either_s.mli.in stdcompat__ephemeron.ml.in stdcompat__ephemeron.mli.in stdcompat__ephemeron_s.mli.in stdcompat__filename.ml.in stdcompat__filename.mli.in stdcompat__filename_s.mli.in stdcompat__float.ml.in stdcompat__float.mli.in stdcompat__float_s.mli.in stdcompat__format.ml.in stdcompat__format.mli.in stdcompat__format_s.mli.in stdcompat__fun.ml.in stdcompat__fun.mli.in stdcompat__fun_s.mli.in stdcompat__hashtbl.ml.in stdcompat__hashtbl.mli.in stdcompat__hashtbl_ext.ml.in stdcompat__hashtbl_ext.mli.in stdcompat__hashtbl_s.mli.in stdcompat__in_channel.ml.in stdcompat__in_channel.mli.in stdcompat__in_channel_s.mli.in stdcompat__init.ml.in stdcompat__init.mli.in stdcompat__int.ml.in stdcompat__int.mli.in stdcompat__int32.ml.in stdcompat__int32.mli.in stdcompat__int32_s.mli.in stdcompat__int64.ml.in stdcompat__int64.mli.in stdcompat__int64_s.mli.in stdcompat__int_s.mli.in stdcompat__lazy.ml.in stdcompat__lazy.mli.in stdcompat__lazy_s.mli.in stdcompat__lexing.ml.in stdcompat__lexing.mli.in stdcompat__lexing_s.mli.in stdcompat__list.ml.in stdcompat__list.mli.in stdcompat__listLabels.ml.in stdcompat__listLabels.mli.in stdcompat__listLabels_s.mli.in stdcompat__list_s.mli.in stdcompat__map.ml.in stdcompat__map.mli.in stdcompat__map_s.mli.in stdcompat__moreLabels.ml.in stdcompat__moreLabels.mli.in stdcompat__moreLabels_s.mli.in stdcompat__native.ml_byte.in stdcompat__native.ml_native.in stdcompat__nativeint.ml.in stdcompat__nativeint.mli.in stdcompat__nativeint_s.mli.in stdcompat__option.ml.in stdcompat__option.mli.in stdcompat__option_s.mli.in stdcompat__out_channel.ml.in stdcompat__out_channel.mli.in stdcompat__out_channel_s.mli.in stdcompat__pervasives.ml.in stdcompat__pervasives.mli.in stdcompat__pervasives_s.mli.in stdcompat__printexc.ml.in stdcompat__printexc.mli.in stdcompat__printexc_s.mli.in stdcompat__printf.ml.in stdcompat__printf.mli.in stdcompat__printf_s.mli.in stdcompat__queue.ml.in stdcompat__queue.mli.in stdcompat__queue_s.mli.in stdcompat__random.ml.in stdcompat__random.mli.in stdcompat__random_s.mli.in stdcompat__result.ml.in stdcompat__result.mli.in stdcompat__result_s.mli.in stdcompat__root.ml.in stdcompat__root.mli.in stdcompat__seq.ml.in stdcompat__seq.mli.in stdcompat__seq_s.mli.in stdcompat__set.ml.in stdcompat__set.mli.in stdcompat__set_s.mli.in stdcompat__stack.ml.in stdcompat__stack.mli.in stdcompat__stack_s.mli.in stdcompat__stdlib.ml.in stdcompat__stdlib.mli.in stdcompat__stdlib_s.mli.in stdcompat__string.ml.in stdcompat__string.mli.in stdcompat__stringLabels.ml.in stdcompat__stringLabels.mli.in stdcompat__stringLabels_s.mli.in stdcompat__string_s.mli.in stdcompat__stubs.c.in stdcompat__sys.ml.in stdcompat__sys.mli.in stdcompat__sys_s.mli.in stdcompat__tools.ml.in stdcompat__tools.mli.in stdcompat__uchar.ml.in stdcompat__uchar.mli.in stdcompat__uchar_s.mli.in stdcompat__unit.ml.in stdcompat__unit.mli.in stdcompat__unit_s.mli.in stdcompat__weak.ml.in stdcompat__weak.mli.in stdcompat__weak_s.mli.in stdcompat_tests.ml.in) (action (run sh %{configure}))) ocaml-stdcompat-20~git20240529/dune-project000066400000000000000000000000411463722102200204320ustar00rootroot00000000000000(lang dune 2.0) (name stdcompat) ocaml-stdcompat-20~git20240529/generate_interfaces.sh000077500000000000000000000020541463722102200224520ustar00rootroot00000000000000#!/usr/bin/env bash set -e opam config exec --switch=4.07.0+rc1 -- \ ocamlfind ocamlc -g -package unix,compiler-libs.common -linkpkg \ interface_generator.ml -o interface_generator for module in \ Pervasives Arg Array ArrayLabels Buffer Bytes BytesLabels Callback Char \ Complex Digest Ephemeron Filename Float Format Gc Genlex Hashtbl Int32 \ Int64 Lazy Lexing List ListLabels Map Marshal MoreLabels Nativeint Obj Oo \ Option Parsing Printexc Printf Queue Random Result Scanf Seq Set Sort \ Spacetime Stack StdLabels Stream String StringLabels Sys Uchar Weak; do target=stdcompat__`echo $module | tr A-Z a-z`.mli.in echo $module ./interface_generator $module \ ~/.opam/4.07.0+rc1/bin/ocaml \ ~/.opam/4.06.1/bin/ocaml \ ~/.opam/4.05.0/bin/ocaml \ ~/.opam/4.04.2/bin/ocaml \ ~/.opam/4.03.0/bin/ocaml \ ~/.opam/4.02.3/bin/ocaml \ ~/.opam/4.01.0/bin/ocaml \ ~/.opam/4.00.1/bin/ocaml \ ~/.opam/3.12.1/bin/ocaml \ ~/.opam/3.11.2/bin/ocaml >$target done ocaml-stdcompat-20~git20240529/install-sh000077500000000000000000000357761463722102200201430ustar00rootroot00000000000000#!/bin/sh # install - install a program, script, or datafile scriptversion=2020-11-14.01; # UTC # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # 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 # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # 'make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. tab=' ' nl=' ' IFS=" $tab$nl" # Set DOITPROG to "echo" to test this script. doit=${DOITPROG-} doit_exec=${doit:-exec} # Put in absolute file names if you don't have them in your path; # or use environment vars. chgrpprog=${CHGRPPROG-chgrp} chmodprog=${CHMODPROG-chmod} chownprog=${CHOWNPROG-chown} cmpprog=${CMPPROG-cmp} cpprog=${CPPROG-cp} mkdirprog=${MKDIRPROG-mkdir} mvprog=${MVPROG-mv} rmprog=${RMPROG-rm} stripprog=${STRIPPROG-strip} posix_mkdir= # Desired mode of installed file. mode=0755 # Create dirs (including intermediate dirs) using mode 755. # This is like GNU 'install' as of coreutils 8.32 (2020). mkdir_umask=22 backupsuffix= chgrpcmd= chmodcmd=$chmodprog chowncmd= mvcmd=$mvprog rmcmd="$rmprog -f" stripcmd= src= dst= dir_arg= dst_arg= copy_on_change=false is_target_a_directory=possibly usage="\ Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE or: $0 [OPTION]... SRCFILES... DIRECTORY or: $0 [OPTION]... -t DIRECTORY SRCFILES... or: $0 [OPTION]... -d DIRECTORIES... In the 1st form, copy SRCFILE to DSTFILE. In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. In the 4th, create DIRECTORIES. Options: --help display this help and exit. --version display version info and exit. -c (ignored) -C install only if different (preserve data modification time) -d create directories instead of installing files. -g GROUP $chgrpprog installed files to GROUP. -m MODE $chmodprog installed files to MODE. -o USER $chownprog installed files to USER. -p pass -p to $cpprog. -s $stripprog installed files. -S SUFFIX attempt to back up existing files, with suffix SUFFIX. -t DIRECTORY install into DIRECTORY. -T report an error if DSTFILE is a directory. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG By default, rm is invoked with -f; when overridden with RMPROG, it's up to you to specify -f if you want it. If -S is not specified, no backups are attempted. Email bug reports to bug-automake@gnu.org. Automake home page: https://www.gnu.org/software/automake/ " while test $# -ne 0; do case $1 in -c) ;; -C) copy_on_change=true;; -d) dir_arg=true;; -g) chgrpcmd="$chgrpprog $2" shift;; --help) echo "$usage"; exit $?;; -m) mode=$2 case $mode in *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) echo "$0: invalid mode: $mode" >&2 exit 1;; esac shift;; -o) chowncmd="$chownprog $2" shift;; -p) cpprog="$cpprog -p";; -s) stripcmd=$stripprog;; -S) backupsuffix="$2" shift;; -t) is_target_a_directory=always dst_arg=$2 # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac shift;; -T) is_target_a_directory=never;; --version) echo "$0 $scriptversion"; exit $?;; --) shift break;; -*) echo "$0: invalid option: $1" >&2 exit 1;; *) break;; esac shift done # We allow the use of options -d and -T together, by making -d # take the precedence; this is for compatibility with GNU install. if test -n "$dir_arg"; then if test -n "$dst_arg"; then echo "$0: target directory not allowed when installing a directory." >&2 exit 1 fi fi if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then # When -d is used, all remaining arguments are directories to create. # When -t is used, the destination is already specified. # Otherwise, the last argument is the destination. Remove it from $@. for arg do if test -n "$dst_arg"; then # $@ is not empty: it contains at least $arg. set fnord "$@" "$dst_arg" shift # fnord fi shift # arg dst_arg=$arg # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac done fi if test $# -eq 0; then if test -z "$dir_arg"; then echo "$0: no input file specified." >&2 exit 1 fi # It's OK to call 'install-sh -d' without argument. # This can happen when creating conditional directories. exit 0 fi if test -z "$dir_arg"; then if test $# -gt 1 || test "$is_target_a_directory" = always; then if test ! -d "$dst_arg"; then echo "$0: $dst_arg: Is not a directory." >&2 exit 1 fi fi fi if test -z "$dir_arg"; then do_exit='(exit $ret); exit $ret' trap "ret=129; $do_exit" 1 trap "ret=130; $do_exit" 2 trap "ret=141; $do_exit" 13 trap "ret=143; $do_exit" 15 # Set umask so as not to create temps with too-generous modes. # However, 'strip' requires both read and write access to temps. case $mode in # Optimize common cases. *644) cp_umask=133;; *755) cp_umask=22;; *[0-7]) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw='% 200' fi cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; *) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw=,u+rw fi cp_umask=$mode$u_plus_rw;; esac fi for src do # Protect names problematic for 'test' and other utilities. case $src in -* | [=\(\)!]) src=./$src;; esac if test -n "$dir_arg"; then dst=$src dstdir=$dst test -d "$dstdir" dstdir_status=$? # Don't chown directories that already exist. if test $dstdir_status = 0; then chowncmd="" fi else # Waiting for this to be detected by the "$cpprog $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst_arg"; then echo "$0: no destination specified." >&2 exit 1 fi dst=$dst_arg # If destination is a directory, append the input filename. if test -d "$dst"; then if test "$is_target_a_directory" = never; then echo "$0: $dst_arg: Is a directory" >&2 exit 1 fi dstdir=$dst dstbase=`basename "$src"` case $dst in */) dst=$dst$dstbase;; *) dst=$dst/$dstbase;; esac dstdir_status=0 else dstdir=`dirname "$dst"` test -d "$dstdir" dstdir_status=$? fi fi case $dstdir in */) dstdirslash=$dstdir;; *) dstdirslash=$dstdir/;; esac obsolete_mkdir_used=false if test $dstdir_status != 0; then case $posix_mkdir in '') # With -d, create the new directory with the user-specified mode. # Otherwise, rely on $mkdir_umask. if test -n "$dir_arg"; then mkdir_mode=-m$mode else mkdir_mode= fi posix_mkdir=false # The $RANDOM variable is not portable (e.g., dash). Use it # here however when possible just to lower collision chance. tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ trap ' ret=$? rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null exit $ret ' 0 # Because "mkdir -p" follows existing symlinks and we likely work # directly in world-writeable /tmp, make sure that the '$tmpdir' # directory is successfully created first before we actually test # 'mkdir -p'. if (umask $mkdir_umask && $mkdirprog $mkdir_mode "$tmpdir" && exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1 then if test -z "$dir_arg" || { # Check for POSIX incompatibilities with -m. # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or # other-writable bit of parent directory when it shouldn't. # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. test_tmpdir="$tmpdir/a" ls_ld_tmpdir=`ls -ld "$test_tmpdir"` case $ls_ld_tmpdir in d????-?r-*) different_mode=700;; d????-?--*) different_mode=755;; *) false;; esac && $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" } } then posix_mkdir=: fi rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" else # Remove any dirs left behind by ancient mkdir implementations. rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null fi trap '' 0;; esac if $posix_mkdir && ( umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ) then : else # mkdir does not conform to POSIX, # or it failed possibly due to a race condition. Create the # directory the slow way, step by step, checking for races as we go. case $dstdir in /*) prefix='/';; [-=\(\)!]*) prefix='./';; *) prefix='';; esac oIFS=$IFS IFS=/ set -f set fnord $dstdir shift set +f IFS=$oIFS prefixes= for d do test X"$d" = X && continue prefix=$prefix$d if test -d "$prefix"; then prefixes= else if $posix_mkdir; then (umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break # Don't fail if two instances are running concurrently. test -d "$prefix" || exit 1 else case $prefix in *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; *) qprefix=$prefix;; esac prefixes="$prefixes '$qprefix'" fi fi prefix=$prefix/ done if test -n "$prefixes"; then # Don't fail if two instances are running concurrently. (umask $mkdir_umask && eval "\$doit_exec \$mkdirprog $prefixes") || test -d "$dstdir" || exit 1 obsolete_mkdir_used=true fi fi fi if test -n "$dir_arg"; then { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 else # Make a couple of temp file names in the proper directory. dsttmp=${dstdirslash}_inst.$$_ rmtmp=${dstdirslash}_rm.$$_ # Trap to clean up those temp files at exit. trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 # Copy the file name to the temp name. (umask $cp_umask && { test -z "$stripcmd" || { # Create $dsttmp read-write so that cp doesn't create it read-only, # which would cause strip to fail. if test -z "$doit"; then : >"$dsttmp" # No need to fork-exec 'touch'. else $doit touch "$dsttmp" fi } } && $doit_exec $cpprog "$src" "$dsttmp") && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $cpprog $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && # If -C, don't bother to copy if it wouldn't change the file. if $copy_on_change && old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && set -f && set X $old && old=:$2:$4:$5:$6 && set X $new && new=:$2:$4:$5:$6 && set +f && test "$old" = "$new" && $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 then rm -f "$dsttmp" else # If $backupsuffix is set, and the file being installed # already exists, attempt a backup. Don't worry if it fails, # e.g., if mv doesn't support -f. if test -n "$backupsuffix" && test -f "$dst"; then $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null fi # Rename the file to the real destination. $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || # The rename failed, perhaps because mv can't rename something else # to itself, or perhaps because mv is so ancient that it does not # support -f. { # Now remove or move aside any old file at destination location. # We try this two ways since rm can't unlink itself on some # systems and the destination file might be busy for other # reasons. In this case, the final cleanup might fail but the new # file should still install successfully. { test ! -f "$dst" || $doit $rmcmd "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && { $doit $rmcmd "$rmtmp" 2>/dev/null; :; } } || { echo "$0: cannot unlink or rename $dst" >&2 (exit 1); exit 1 } } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dst" } fi || exit 1 trap '' 0 fi done # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: ocaml-stdcompat-20~git20240529/interface_generator/000077500000000000000000000000001463722102200221235ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interface_generator/Makefile000066400000000000000000000037241463722102200235710ustar00rootroot00000000000000OCAMLFIND := ocamlfind OCAMLFIND_AVAILABLE := $(shell \ if $(OCAMLFIND) query -help >/dev/null 2>&1; then \ echo true; \ else \ echo false; \ fi \ ) ifeq ($(OCAMLFIND_AVAILABLE),true) OCAMLOPT := $(OCAMLFIND) ocamlopt OCAMLC := $(OCAMLFIND) ocamlc OCAMLDOC := $(OCAMLFIND) ocamldoc OCAMLDEP := $(OCAMLFIND) ocamldep OCAMLFLAGS := -package unix,compiler-libs.common OCAMLLDFLAGS := -linkpkg else OCAMLOPT := $(shell \ if ocamlopt.opt -version >/dev/null 2>&1; then \ echo ocamlopt.opt; \ elif ocamlopt -version >/dev/null 2>&1; then \ echo ocamlopt; \ fi \ ) OCAMLC := $(shell \ if ocamlc.opt -version >/dev/null 2>&1; then \ echo ocamlc.opt; \ elif ocamlc -version >/dev/null 2>&1; then \ echo ocamlc; \ fi \ ) OCAMLDOC := ocamldoc OCAMLDEP := ocamldep endif OCAMLFLAGS += -g OCAMLCFLAGS += $(OCAMLFLAGS) OCAMLLDFLAGS += $(OCAMLFLAGS) ifeq ($(OCAMLC),) $(error There is no OCaml compiler available in PATH) endif ifeq ($(OCAMLOPT),) OCAMLOPT_AVAILABLE := false else OCAMLOPT_AVAILABLE := $(shell \ if $(OCAMLOPT) -version >/dev/null 2>&1; then \ echo true; \ else \ echo false; \ fi \ ) endif ifeq ($(OCAMLOPT_AVAILABLE),true) OCAMLBEST := $(OCAMLOPT) CMOX := cmx else OCAMLBEST := $(OCAMLC) CMOX := cmo endif MODULES := interface_tools.ml interface_dumper.ml interface_generator.ml all : interface_dumper interface_generator clean : - rm -f $(MODULES:.ml=.cmo) $(MODULES:.ml=.cmx) $(MODULES:.ml=.cmi) \ $(MODULES:.ml=.o) .depend .depend : $(MODULES) $(MODULES:.ml=.mli) $(OCAMLDEP) $^ >$@ ifneq ($(MAKECMDGOALS),clean) -include .depend endif interface_dumper : interface_tools.$(CMOX) interface_dumper.$(CMOX) $(OCAMLBEST) $(OCAMLLDFLAGS) $^ -o $@ interface_generator : interface_tools.$(CMOX) interface_generator.$(CMOX) $(OCAMLBEST) $(OCAMLLDFLAGS) $^ -o $@ %.cmi : %.mli $(OCAMLC) $(OCAMLCFLAGS) -c $< -o $@ %.cmo : %.ml $(OCAMLC) $(OCAMLCFLAGS) -c $< -o $@ %.cmx : %.ml $(OCAMLOPT) $(OCAMLCFLAGS) -c $< -o $@ ocaml-stdcompat-20~git20240529/interface_generator/dump_interfaces.sh000077500000000000000000000021041463722102200256270ustar00rootroot00000000000000#!/usr/bin/env bash set -e # 3.11.2 3.12.1 4.00.1 # 4.01.0 4.02.3 4.03.0 4.04.2 4.05.0 4.06.1 \ # 4.07.0 \ # 4.08 4.09 4.10 4.11 4.12 4.13 4.14 for ocaml_version in 5.2 5.1 5.0; do target_dir=../interfaces/$ocaml_version # ocaml_version=ocaml-variants.4.10.0+beta2 # target_dir=../interfaces/4.10.0 mkdir -p $target_dir for module in Stack \ Stdlib Atomic Arg Array ArrayLabels Bool Buffer Bytes BytesLabels Callback Char \ Complex Digest Domain Either Ephemeron Filename Float Format Fun Gc Hashtbl Int32 \ Int64 Lazy Lexing List ListLabels Map Marshal MoreLabels Nativeint Obj \ Oo Option Parsing Printexc Printf Queue Random Result Scanf Seq Set \ StdLabels String StringLabels Sys Uchar Weak In_channel Out_channel \ Unit ; do target=$target_dir/`echo ${module:0:1} | tr A-Z a-z`${module:1}.mli echo $target opam exec --switch=$ocaml_version -- \ ./interface_dumper $module ocaml >$target # [ `stat --format="%s" $target` -gt 1 ] || rm $target # [ `stat -f%z $target` -gt 1 ] || rm $target done done ocaml-stdcompat-20~git20240529/interface_generator/generate_interfaces.sh000077500000000000000000000000611463722102200264540ustar00rootroot00000000000000#!/usr/bin/env bash set -e ./interface_generator ocaml-stdcompat-20~git20240529/interface_generator/interface_dumper.ml000066400000000000000000000224331463722102200257750ustar00rootroot00000000000000let run_interpreter ?(buffer_size = 4096) ~command_line ~module_name commander = let channels = Unix.open_process_full command_line (Unix.environment ()) in Fun.protect ~finally:(fun () -> assert (channels |> Unix.close_process_full = Unix.WEXITED 0)) (fun () -> let in_channel, out_channel, err_channel = channels in let buffer = Buffer.create buffer_size in let rec wait_for_prompt () = let _ : int = Interface_tools.Buffer.add_channel_no_wait buffer in_channel buffer_size in if not (Interface_tools.Buffer.has_suffix buffer "# ") then wait_for_prompt () in wait_for_prompt (); let prolog = Buffer.contents buffer in let linefeed_index = String.index prolog '\n' in let version_line = String.sub prolog 0 linefeed_index in let version = Interface_tools.Version.of_string version_line in commander version (fun phrase -> let str = String.trim (Format.asprintf "%a@." Pprintast.top_phrase phrase) in let str = if Interface_tools.String.has_prefix ~prefix:";;" str then Interface_tools.String.suffix_from str 2 else str in Printf.fprintf out_channel "\n%s\n\n" str; flush out_channel; Buffer.clear buffer; Interface_tools.Buffer.add_channel_to_the_end buffer in_channel ~continue:(fun () -> not (Interface_tools.Buffer.has_suffix buffer "# ")); if Buffer.length buffer > 4 then Buffer.truncate buffer (Buffer.length buffer - 4); Buffer.contents buffer)) let module_type_of_string ~module_name s = match let lexbuf = s |> Lexing.from_string in Lexing.set_filename lexbuf module_name; match Parse.interface lexbuf with | [{ psig_desc = Psig_module { pmd_type = module_type } }] -> module_type | [{ psig_desc = Psig_modtype { pmtd_type = Some module_type }}] -> module_type | _ -> failwith "Unexpected result" with | s -> s | exception ((Syntaxerr.Error _) as exn) -> prerr_endline s; (* Syntaxerr.report_error is deprecated *) begin match Location.error_of_exn exn with | Some (`Ok err) -> Location.print_report Format.err_formatter err | _ -> () end; { pmty_desc = Pmty_signature []; pmty_loc = Location.none; pmty_attributes = [] } | exception e -> prerr_endline s; prerr_endline (Printexc.to_string e); { pmty_desc = Pmty_signature []; pmty_loc = Location.none; pmty_attributes = [] } let refine_signature_item ~module_name (interpret : Parsetree.toplevel_phrase -> string) (signature_item : Parsetree.signature_item) = match signature_item.psig_desc with | Psig_value value_description -> let pstr_desc : Parsetree.structure_item_desc = Pstr_eval (Ast_helper.Exp.ident (Location.mkloc (Longident.Ldot ( Lident module_name, value_description.pval_name.txt)) !Ast_helper.default_loc), []) in let s = interpret (Ptop_def [{ pstr_desc; pstr_loc = Location.none }]) in let lines = String.split_on_char '\n' s in let rec chop_warning lines = match lines with | s :: s' :: _ when Interface_tools.String.has_prefix ~prefix:"Warning 3:" s || Interface_tools.String.has_prefix ~prefix:"Warning 3:" s -> Some s' | _ :: tl -> chop_warning tl | [] -> None in let warning = chop_warning lines in let signature_item = match warning with | None -> signature_item | Some warning -> let value_description = { value_description with pval_attributes = Ast_helper.Attr.mk (Location.mkloc "ocaml.deprecated" !Ast_helper.default_loc) (PStr [Ast_helper.Str.eval (Ast_helper.Exp.constant (Ast_helper.Const.string warning))]) :: value_description.pval_attributes } in { signature_item with psig_desc = Psig_value value_description } in signature_item | _ -> signature_item let refine_module_type ~module_name interpret (module_type : Parsetree.module_type) = match module_type.pmty_desc with | Pmty_signature s -> let s = List.map (refine_signature_item ~module_name interpret) s in { module_type with pmty_desc = Pmty_signature s } | _ -> module_type let self_name ~(module_name : Longident.t) (type_declaration : Parsetree.type_declaration) : Longident.t = if module_name = Lident "Pervasives" then Lident type_declaration.ptype_name.txt else Ldot (module_name, type_declaration.ptype_name.txt) let rec remove_self_aliases_of_type_declaration ~module_name (type_declaration : Parsetree.type_declaration) = match type_declaration.ptype_manifest with | Some { ptyp_desc = Ptyp_constr ({ txt = ident }, _args) } when ident = self_name ~module_name type_declaration -> { type_declaration with ptype_manifest = None } | _ -> type_declaration let rec remove_self_aliases_of_module_type ~module_name (module_type : Parsetree.module_type) = match module_type.pmty_desc with | Pmty_functor (Named (var, arg), body) -> let module_name : Longident.t = Lapply (module_name, Lident (Option.get var.txt)) in let body = remove_self_aliases_of_module_type ~module_name body in { module_type with pmty_desc = Pmty_functor (Named (var, arg), body) } | Pmty_signature s -> let s = s |> List.map @@ remove_self_aliases_of_signature_item ~module_name in { module_type with pmty_desc = Pmty_signature s } | _ -> module_type and remove_self_aliases_of_signature_item ~module_name (item : Parsetree.signature_item) = match item.psig_desc with | Psig_type (rec_flag, list) -> let list = list |> List.map @@ remove_self_aliases_of_type_declaration ~module_name in { item with psig_desc = Psig_type (rec_flag, list) } | Psig_module module_declaration -> let module_name : Longident.t = Ldot (module_name, Option.get module_declaration.pmd_name.txt) in let pmd_type = remove_self_aliases_of_module_type ~module_name module_declaration.pmd_type in { item with psig_desc = Psig_module { module_declaration with pmd_type }} | _ -> item let module_type_of_name ~command_line ~module_name = run_interpreter ~command_line ~module_name (fun version interpret -> let pstr_desc : Parsetree.structure_item_desc = let stdlib_module_name = if Interface_tools.Version.compare version { major = 4; minor = 7; patch = 0 } >= 0 && module_name <> "Pervasives" && module_name <> "Stdlib" then if Interface_tools.Version.compare version { major = 4; minor = 13; patch = 0 } >= 0 then Printf.sprintf "Stdlib__%s" module_name else Printf.sprintf "Stdlib__%s" (String.uncapitalize_ascii module_name) else module_name in let module_expr : Parsetree.module_expr = { pmod_desc = Pmod_ident { txt = Lident stdlib_module_name; loc = Location.none }; pmod_loc = Location.none; pmod_attributes = [] } in if Interface_tools.Version.compare version { major = 4; minor = 2; patch = 0 } >= 0 then Pstr_modtype { pmtd_name = { txt = module_name; loc = Location.none }; pmtd_type = Some ({ pmty_desc = Pmty_typeof module_expr; pmty_loc = Location.none; pmty_attributes = [] }); pmtd_attributes = [Ast_helper.Attr.mk { Location.txt = "ocaml.warning"; loc = Location.none } (Parsetree.PStr [Ast_helper.Str.eval ( Ast_helper.Exp.constant (Ast_helper.Const.string "-3"))]) ]; pmtd_loc = Location.none; } else Pstr_module { pmb_name = { txt = Some module_name; loc = Location.none }; pmb_expr = module_expr; pmb_attributes = []; pmb_loc = Location.none; } in let s = interpret (Ptop_def [{ pstr_desc; pstr_loc = Location.none }]) in let module_type = module_type_of_string ~module_name s in let module_type = if Interface_tools.Version.compare version { major = 4; minor = 2; patch = 0 } >= 0 then module_type else remove_self_aliases_of_module_type ~module_name:(Lident module_name) module_type in let module_type = refine_module_type ~module_name interpret module_type in let _ : string = interpret (Ptop_def [Ast_helper.Str.eval ( Ast_helper.Exp.apply (Ast_helper.Exp.ident (Location.mkloc (Longident.Lident "exit") !Ast_helper.default_loc)) [Nolabel, Ast_helper.Exp.constant (Pconst_integer ("0", None))])]) in module_type) let main () = let module_name, command_line = match Sys.argv with | [| _; module_name; command_line |] -> module_name, command_line | _ -> failwith "Bad usage" in let module_type = module_type_of_name ~command_line ~module_name in let signature = match module_type.pmty_desc with | Pmty_signature signature -> signature | _ -> failwith "Unexpected module type" in Format.fprintf Format.std_formatter "%a@." Pprintast.signature signature let () = if not !Sys.interactive then main () ocaml-stdcompat-20~git20240529/interface_generator/interface_dumper.mli000066400000000000000000000000001463722102200261300ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interface_generator/interface_generator.ml000066400000000000000000001773261463722102200265030ustar00rootroot00000000000000module String = struct include String let hash = Hashtbl.hash module Map = Map.Make (String) end module List = struct include List let equal p l l' = List.compare_lengths l l' = 0 && List.for_all2 p l l' let rec last l = match l with | [] -> failwith "last" | [item] -> item | _ :: tl -> last tl let rec filter_map f l = match l with | [] -> [] | hd :: tl -> match f hd with | None -> filter_map f tl | Some hd' -> hd' :: filter_map f tl end module Name = struct type t = string Location.loc let equal (n : t) (n' : t) = n.txt = n'.txt end module Pair = struct type ('a, 'b) t = 'a * 'b let map_snd f (x, y) = (x, f y) let with_snd f (_x, y) = f y module Hashed (X : Hashtbl.HashedType) (Y : Hashtbl.HashedType) = struct type t = X.t * Y.t let equal (x, y) (x', y') = X.equal x x' && Y.equal y y' let hash (x, y) = Hashtbl.hash (X.hash x, Y.hash y) end end type isomorphism_kind = Ignore_attributes | Attributes_equal let is_attribute_isomorphic kind (a : Parsetree.attribute) (b : Parsetree.attribute) = Name.equal a.attr_name b.attr_name let is_attributes_isomorphic kind (a : Parsetree.attributes) (a' : Parsetree.attributes) = match kind with | Ignore_attributes -> true | Attributes_equal -> List.equal (is_attribute_isomorphic kind) a a' let rec is_core_type_isomorphic kind (t : Parsetree.core_type) (t' : Parsetree.core_type) = is_attributes_isomorphic kind t.ptyp_attributes t'.ptyp_attributes && match t.ptyp_desc, t'.ptyp_desc with | Ptyp_any, Ptyp_any -> true | Ptyp_var v, Ptyp_var v' -> kind = Ignore_attributes || v = v' | Ptyp_arrow (l, u, v), Ptyp_arrow (l', u', v') -> l = l' && is_core_type_isomorphic kind u u' && is_core_type_isomorphic kind v v' | Ptyp_tuple l, Ptyp_tuple l' -> List.equal (is_core_type_isomorphic kind) l l' | Ptyp_constr (c, args), Ptyp_constr (c', args') -> let eq_c, args, args' = match kind, (c.txt, args), (c'.txt, args') with | Ignore_attributes, (Lident "format6", [a; b; c; _; _; f] | Lident "format4", [a; b; c; f]), (Lident "format6", [a'; b'; c'; _; _; f'] | Lident "format4", [a'; b'; c'; f']) -> true, [a; b; c; f], [a'; b'; c'; f'] | _ -> c.txt = c'.txt, args, args' in eq_c && List.equal (is_core_type_isomorphic kind) args args' | Ptyp_alias (c, v), Ptyp_alias (c', v') -> is_core_type_isomorphic kind c c' && v = v' | Ptyp_object (l, flag), Ptyp_object (l', flag') -> List.equal (is_object_field_isomorphic kind) l l' && flag = flag' | Ptyp_poly (l, t), Ptyp_poly (l', t') -> List.equal Name.equal l l' && is_core_type_isomorphic kind t t' | Ptyp_variant _, _ -> Format.fprintf Format.err_formatter "Unknown isomorphism variant: %a@." Pprintast.core_type t; false | _ -> Format.fprintf Format.err_formatter "Unknown isomorphism: %a@." Pprintast.core_type t; false and is_object_field_isomorphic kind (f : Parsetree.object_field) (f' : Parsetree.object_field) = is_attributes_isomorphic kind f.pof_attributes f'.pof_attributes && match f.pof_desc, f'.pof_desc with | Otag (l, t), Otag (l', t') -> l.txt = l'.txt && is_core_type_isomorphic kind t t' | Oinherit t, Oinherit t' -> is_core_type_isomorphic kind t t' | _ -> false let is_label_declaration_isomorphic kind (l : Parsetree.label_declaration) (l' : Parsetree.label_declaration) = Name.equal l.pld_name l'.pld_name && l.pld_mutable = l'.pld_mutable && is_core_type_isomorphic kind l.pld_type l'.pld_type let is_constructor_arguments_isomorphic kind (a : Parsetree.constructor_arguments) (a' : Parsetree.constructor_arguments) = match a, a' with | Pcstr_tuple l, Pcstr_tuple l' -> List.equal (is_core_type_isomorphic kind) l l' | Pcstr_record l, Pcstr_record l' -> List.equal (is_label_declaration_isomorphic kind) l l' | _ -> false let is_constructor_declaration_isomorphic kind (c : Parsetree.constructor_declaration) (c' : Parsetree.constructor_declaration) = Name.equal c.pcd_name c'.pcd_name && is_attributes_isomorphic kind c.pcd_attributes c'.pcd_attributes && is_constructor_arguments_isomorphic kind c.pcd_args c'.pcd_args && Interface_tools.Option.equal (is_core_type_isomorphic kind) c.pcd_res c'.pcd_res let no_self_manifest (d : Parsetree.type_declaration) = match d.ptype_manifest with | Some ({ ptyp_desc = Ptyp_constr ({ txt = Lident self }, _args)}) when self = d.ptype_name.txt -> None | manifest -> manifest let is_type_param_isomorphic kind (ty, (v, i)) (ty', (v', i')) = is_core_type_isomorphic kind ty ty' && v = v' (*&& i = i'*) let is_type_params_isomorphic kind params params' = List.equal (is_type_param_isomorphic kind) params params' let is_type_declaration_isomorphic kind (d : Parsetree.type_declaration) (d' : Parsetree.type_declaration) = Name.equal d.ptype_name d'.ptype_name && is_attributes_isomorphic kind d.ptype_attributes d'.ptype_attributes && is_type_params_isomorphic kind d.ptype_params d'.ptype_params && Interface_tools.Option.equal (is_core_type_isomorphic kind) (no_self_manifest d) (no_self_manifest d') && match d.ptype_kind, d'.ptype_kind with | Ptype_abstract, Ptype_abstract | Ptype_open, Ptype_open -> true | Ptype_variant c, Ptype_variant c' -> List.equal (is_constructor_declaration_isomorphic kind) c c' | Ptype_record r, Ptype_record r' -> List.equal (is_label_declaration_isomorphic kind) r r' | _ -> false module Type_declaration_block = struct type t = { rec_flag : Asttypes.rec_flag; type_decl : Parsetree.type_declaration list; } let get_first_type_name b = match b.type_decl with | [] -> failwith "empty type decl" | type_decl :: _ -> type_decl.ptype_name.txt let is_isomorphic kind b b' = (kind == Ignore_attributes || b.rec_flag = b'.rec_flag) && List.equal (is_type_declaration_isomorphic kind) b.type_decl b'.type_decl end module Signature = struct type t = { values : Parsetree.value_description String.Map.t; types : Type_declaration_block.t String.Map.t; module_types : Parsetree.module_type_declaration String.Map.t; modules : Parsetree.module_declaration String.Map.t; } let empty = { values = String.Map.empty; types = String.Map.empty; module_types = String.Map.empty; modules = String.Map.empty; } let add_value (value_desc : Parsetree.value_description) s = let values = String.Map.add value_desc.pval_name.txt value_desc s.values in { s with values } let add_type_declaration (type_decl : Parsetree.type_declaration) block s = let types = String.Map.add type_decl.ptype_name.txt block s.types in { s with types } let add_type_declaration_block (block : Type_declaration_block.t) s = block.type_decl |> List.fold_left (fun s decl -> add_type_declaration decl block s) s let add_module_type_declaration (module_type_declaration : Parsetree.module_type_declaration) s = let module_types = String.Map.add module_type_declaration.pmtd_name.txt module_type_declaration s.module_types in { s with module_types } let add_module_declaration (module_declaration : Parsetree.module_declaration) s = let modules = String.Map.add (Option.get module_declaration.pmd_name.txt) module_declaration s.modules in { s with modules } let add_item (item : Parsetree.signature_item) s = match item.psig_desc with | Psig_value value_desc -> add_value value_desc s | Psig_type (_rec_flag, type_decl) -> add_type_declaration_block { rec_flag = Recursive; type_decl } s | Psig_modtype module_type_declaration -> add_module_type_declaration module_type_declaration s | Psig_module module_declaration -> add_module_declaration module_declaration s | _ -> s let of_parsetree s = s |> List.fold_left (fun s item -> add_item item s) empty end let lex_file filename parser = let in_channel = filename |> open_in in Fun.protect ~finally:(fun () -> in_channel |> close_in) (fun () -> let buf = in_channel |> Lexing.from_channel in Lexing.set_filename buf filename; buf |> parser) module type Type = sig type t end module SignaturesTable = Hashtbl.Make (Pair.Hashed (Interface_tools.Version) (String)) let signatures = SignaturesTable.create 17 let loc_of_txt txt : 'a Location.loc = { txt; loc = Location.none } let core_type_of_desc ptyp_desc : Parsetree.core_type = Ast_helper.Typ.mk ptyp_desc let module_type_of_desc pmty_desc : Parsetree.module_type = { pmty_desc; pmty_loc = Location.none; pmty_attributes = [] } let module_type_of_signature signature = module_type_of_desc (Pmty_signature signature) let signature_of_module_type (modtype : Parsetree.module_type) = match modtype.pmty_desc with | Pmty_signature s -> s | _ -> failwith "signature_of_module_type" let module_type_of_name version module_name = let root_module, submodule_path = match Longident.flatten module_name with | root_module :: submodule_path -> root_module, submodule_path | [] -> assert false in let root_signature = try prerr_endline "in cache"; SignaturesTable.find signatures (version, root_module) with Not_found -> let root_module_mli = Printf.sprintf "../interfaces/%s/%s.mli" (Interface_tools.Version.to_string ~include_patch:false version) (String.uncapitalize_ascii root_module) in prerr_endline root_module_mli; let root_signature = match lex_file root_module_mli Parse.interface with | root_signature -> root_signature | exception (Sys_error _) -> [] in if root_signature = [] then prerr_endline "Parsed an empty signature!"; SignaturesTable.add signatures (version, root_module) root_signature; root_signature in let rec lookup_submodule signature hd tl = Format.eprintf "Looking for submodule %s@." hd; if signature = [] then prerr_endline "Empty signature!"; let module_type = Option.get ( signature |> List.find_map ( fun (signature_item : Parsetree.signature_item) -> match signature_item.psig_desc with | Psig_module module_declaration when Option.get module_declaration.pmd_name.txt = hd -> Some module_declaration.pmd_type | Psig_module module_declaration -> prerr_endline (Option.get module_declaration.pmd_name.txt); None | _ -> Format.eprintf "%a@." Pprintast.signature [signature_item]; None)) in match tl with | [] -> module_type | hd :: tl -> let signature = signature_of_module_type module_type in lookup_submodule signature hd tl in match submodule_path with | [] -> module_type_of_signature root_signature | hd :: tl -> lookup_submodule root_signature hd tl module PolymorphicHash (T : Type) = struct type t = T.t let equal = ( = ) let hash = Hashtbl.hash end module ExternalsTable = Hashtbl.Make (Pair.Hashed (PolymorphicHash (Longident)) (Interface_tools.Version)) let externals_table = ExternalsTable.create 17 module StringHashtbl = Hashtbl.Make (String) let normalize_prim version prim = if Interface_tools.Version.compare version { major = 3; minor = 8; patch = 0 } >= 0 then prim else match prim with | "sys_file_exists" -> "caml_sys_file_exists" | "sys_is_directory" -> "caml_sys_is_directory" | "sys_remove" -> "caml_sys_remove" | "sys_rename" -> "caml_sys_rename" | "sys_getenv" -> "caml_sys_getenv" | "sys_system_command" -> "caml_sys_system_command" | "sys_time_unboxed" -> "caml_sys_time_unboxed" | "sys_chdir" -> "caml_sys_chdir" | "sys_getcwd" -> "caml_sys_getcwd" | "sys_read_directory" -> "caml_sys_read_directory" | "runtime_variant" -> "caml_runtime_variant" | "runtime_parameters" -> "caml_runtime_parameters" | "install_signal_handler" -> "caml_install_signal_handler" | "output_value_to_bytes" -> "caml_output_value_to_bytes" | "output_value_to_string" -> "caml_output_value_to_string" | "power_float" -> "caml_power_float" | "sqrt_float" -> "caml_sqrt_float" | "exp_float" -> "caml_exp_float" | "log_float" -> "caml_log_float" | "log10_float" -> "caml_log10_float" | "expm1" -> "caml_expm1" | "log1p" -> "caml_log1p" | "cos_float" -> "caml_cos_float" | "sin_float" -> "caml_sin_float" | "tan_float" -> "caml_tan_float" | "acos_float" -> "caml_acos_float" | "asin_float" -> "caml_asin_float" | "atan_float" -> "caml_atan_float" | "atan2_float" -> "caml_atan2_float" | "hypot" -> "caml_hypot" | "cosh_float" -> "caml_cosh_float" | "sinh_float" -> "caml_sinh_float" | "tanh_float" -> "caml_tanh_float" | "ceil_float" -> "caml_ceil_float" | "floor_float" -> "caml_floor_float" | "copysign" -> "caml_copysign" | "fmod_float" -> "caml_fmod_float" | "frexp_float" -> "caml_frexp_float" | "ldexp_float_unboxed" -> "caml_ldexp_float_unboxed" | "modf_float" -> "caml_modf_float" | "classify_float" -> "caml_classify_float" | "classify_float_unboxed" -> "caml_classify_float_unboxed" | "int_of_string" -> "caml_int_of_string" | "float_of_string" -> "caml_float_of_string" | "create_bytes" -> "caml_create_bytes" | "blit_bytes" -> "caml_blit_bytes" | "fill_bytes" -> "caml_fill_bytes" | "nativeint_of_float" -> "caml_nativeint_of_float" | "nativeint_of_float_unboxed" -> "caml_nativeint_of_float_unboxed" | "nativeint_to_float" -> "caml_nativeint_to_float" | "nativeint_to_float_unboxed" -> "caml_nativeint_to_float_unboxed" | "nativeint_of_string" -> "caml_nativeint_of_string" | "nativeint_format" -> "caml_nativeint_format" | "int32_of_float_unboxed" -> "caml_int32_of_float_unboxed" | "int32_to_float_unboxed" -> "caml_int32_to_float_unboxed" | "int32_of_string" -> "caml_int32_of_string" | "int32_bits_of_float" -> "caml_int32_bits_of_float" | "int32_bits_of_float_unboxed" -> "caml_int32_bits_of_float_unboxed" | "int32_float_of_bits" -> "caml_int32_float_of_bits" | "int32_float_of_bits_unboxed" -> "caml_int32_float_of_bits_unboxed" | "int32_format" -> "caml_int32_format" | "make_vect" -> "caml_make_vect" | "make_float_vect" -> "caml_make_float_vect" | "floatarray_create" -> "caml_floatarray_create" | "obj_tag" -> "caml_obj_tag" | "obj_reachable_words" -> "caml_obj_reachable_words" | "obj_set_tag" -> "caml_obj_set_tag" | "obj_block" -> "caml_obj_block" | "obj_dup" -> "caml_obj_dup" | "obj_truncate" -> "caml_obj_truncate" | "obj_add_offset" -> "caml_obj_add_offset" | "gc_stat" -> "caml_gc_stat" | "gc_quick_stat" -> "caml_gc_quick_stat" | "gc_counters" -> "caml_gc_counters" | "gc_minor_words" -> "caml_gc_minor_words" | "gc_minor_words_unboxed" -> "caml_gc_minor_words_unboxed" | "gc_get" -> "caml_gc_get" | "gc_set" -> "caml_gc_set" | "gc_minor" -> "caml_gc_minor" | "gc_major_slice" -> "caml_gc_major_slice" | "gc_major" -> "caml_gc_major" | "gc_full_major" -> "caml_gc_full_major" | "gc_compaction" -> "caml_gc_compaction" | "get_minor_free" -> "caml_get_minor_free" | "get_major_bucket" -> "caml_get_major_bucket" | "get_major_credit" -> "caml_get_major_credit" | "gc_huge_fallback_count" -> "caml_gc_huge_fallback_count" | "create_string" -> "caml_create_string" | "blit_string" -> "caml_blit_string" | "fill_string" -> "caml_fill_string" | "int64_of_float_unboxed" -> "caml_int64_of_float_unboxed" | "int64_to_float_unboxed" -> "caml_int64_to_float_unboxed" | "int64_of_string" -> "caml_int64_of_string" | "int64_bits_of_float" -> "caml_int64_bits_of_float" | "int64_bits_of_float_unboxed" -> "caml_int64_bits_of_float_unboxed" | "int64_float_of_bits" -> "caml_int64_float_of_bits" | "int64_float_of_bits_unboxed" -> "caml_int64_float_of_bits_unboxed" | "int64_format" -> "caml_int64_format" | "md5_chan" -> "caml_md5_chan" | prim -> prim let get_externals module_name version = try ExternalsTable.find externals_table (module_name, version) with Not_found -> let modtype = module_type_of_name version module_name in let externals = StringHashtbl.create 17 in let add_external (item : Parsetree.signature_item) = match item.psig_desc with | Psig_value ({ pval_prim = prim :: _ } as value_description) -> StringHashtbl.add externals (normalize_prim version prim) value_description | _ -> () in modtype |> signature_of_module_type |> List.iter add_external; ExternalsTable.add externals_table (module_name, version) externals; externals let string_of_longident longident = String.concat "." (Longident.flatten longident) let qualify_type_decl ~module_name (type_decl : Parsetree.type_declaration) = match type_decl.ptype_private with | Private -> { type_decl with ptype_private = Public; ptype_manifest = Some (Ast_helper.Typ.constr { txt = Longident.Ldot (module_name, type_decl.ptype_name.txt); loc = type_decl.ptype_name.loc } (List.map fst type_decl.ptype_params)) } | Public -> let ptype_manifest = type_decl.ptype_manifest |> Option.map @@ fun (ty : Parsetree.core_type) -> match ty.ptyp_desc with | Ptyp_constr ({ txt = Lident "fpclass"; loc }, []) -> let txt = Longident.Ldot (Lident "Stdlib", "fpclass") in let ptyp_desc = Parsetree.Ptyp_constr ({ Location.txt; loc }, []) in { ty with ptyp_desc } | Ptyp_constr ({ txt = Lident ident; loc }, args) when ident <> "char" && ident <> "string" && ident <> "lazy_t" && ident <> "nativeint" && ident <> "int32" && ident <> "int64" && ident <> "format6" && ident <> "format4" && ident <> "bytes" && ident <> "float" && ident <> "result" && ident <> "option" && ident <> "list" && ident <> "bool" && ident <> "array" && ident <> "exn" && ident <> "int" && ident <> "unit" && ident <> "in_channel" && ident <> "out_channel" -> let txt = Longident.Ldot (module_name, ident) in let ptyp_desc = Parsetree.Ptyp_constr ({ Location.txt; loc }, args) in { ty with ptyp_desc } | _ -> ty in { type_decl with ptype_manifest } let format_signature_item ~module_name ~signatures formatter (item : Parsetree.signature_item) = match item.psig_desc with | Psig_type (rec_flag, type_decl) -> let item = { item with psig_desc = Parsetree.Psig_type (rec_flag, type_decl) } in Format.fprintf formatter "%a@." Pprintast.signature [item] | Psig_value value_desc -> () | _ -> () let rec compat_core_type ~module_name (core_type : Parsetree.core_type) = let core_type = { core_type with ptyp_attributes = [] } in match core_type.ptyp_desc with | Ptyp_arrow (label, left, right) -> let ptyp_desc = Parsetree.Ptyp_arrow (label, compat_core_type ~module_name left, compat_core_type ~module_name right) in { core_type with ptyp_desc } | Ptyp_tuple args -> let args = List.map (compat_core_type ~module_name) args in let ptyp_desc = Parsetree.Ptyp_tuple args in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lident "CamlinternalLazy", "t") }, [arg]) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__init", "lazy_t") }, [arg]) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Lident "bytes" }, []) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__init", "bytes") }, []) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Lident "floatarray" }, []) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__init", "floatarray") }, []) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Lident "result" }, [v; e]) -> let v = compat_core_type ~module_name v in let e = compat_core_type ~module_name e in let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__pervasives", "result") }, [v; e]) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lident "Seq", "t") }, [arg]) -> let arg = compat_core_type ~module_name arg in let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__seq", "t") }, [compat_core_type ~module_name arg]) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lident "Stdlib", t) }, args) -> let args = List.map (compat_core_type ~module_name) args in let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__stdlib", t) }, args) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lident "Uchar", t) }, []) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__uchar", t) }, []) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lident "Hashtbl", "statistics") }, []) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__hashtbl_ext", "statistics") }, []) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lapply (Ldot (Lident "Hashtbl", "MakeSeeded"), Lident "H"), "t") }, args) -> let args = List.map (compat_core_type ~module_name) args in let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lapply (Ldot (Lident "Stdcompat__hashtbl_ext", "MakeSeeded"), Lident "H"), "t") }, args) in { core_type with ptyp_desc } | Ptyp_constr ({ loc; txt = Ldot (Lident "Either", "t") }, [a; b]) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__either", "t") }, [a; b]) in { core_type with ptyp_desc } | Ptyp_constr (constr, args) -> let rec remove_module_name (constr : Longident.t) : Longident.t = match constr with | Ldot (module_name', x) -> if module_name = module_name' then Lident x else Ldot (remove_module_name module_name', x) | _ -> constr in let constr = { constr with txt = remove_module_name constr.txt } in let ptyp_desc = Parsetree.Ptyp_constr (constr, List.map (compat_core_type ~module_name) args) in { core_type with ptyp_desc } | _ -> core_type let compat_label_declaration ~module_name (label_declaration : Parsetree.label_declaration) = { label_declaration with pld_type = compat_core_type ~module_name label_declaration.pld_type } let compat_constructor_arguments ~module_name (constructor_arguments : Parsetree.constructor_arguments) : Parsetree.constructor_arguments = match constructor_arguments with | Pcstr_tuple args -> Pcstr_tuple (args |> List.map (compat_core_type ~module_name)) | Pcstr_record label_declarations -> Pcstr_record (label_declarations |> List.map (compat_label_declaration ~module_name)) let compat_constructor_declaration ~module_name (constructor_declaration : Parsetree.constructor_declaration) = { constructor_declaration with pcd_args = compat_constructor_arguments ~module_name constructor_declaration.pcd_args; pcd_res = constructor_declaration.pcd_res |> Interface_tools.Option.map (compat_core_type ~module_name); } let compat_type_kind ~module_name (type_kind : Parsetree.type_kind) : Parsetree.type_kind = match type_kind with | Ptype_variant constructor_declarations -> Ptype_variant (constructor_declarations |> List.map (compat_constructor_declaration ~module_name)) | Ptype_record label_declarations -> Ptype_record (label_declarations |> List.map (compat_label_declaration ~module_name)) | _ -> type_kind let remove_injectivity ptype_params = List.map (fun (ty, (v, _)) -> (ty, (v, Asttypes.NoInjectivity))) ptype_params let compat_type_declaration ~module_name (type_decl : Parsetree.type_declaration) = match Longident.Ldot (module_name, type_decl.ptype_name.txt) with | Ldot (Lident "Pervasives", "format6") -> let ptype_manifest = match type_decl.ptype_manifest with | Some ( { ptyp_desc = Parsetree.Ptyp_constr ({ loc }, args) } as core_type) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__init", "format6") }, args) in Some { core_type with ptyp_desc } | _ -> assert false in { type_decl with ptype_manifest } | Lident "result" -> { type_decl with ptype_manifest = Some (core_type_of_desc (Ptyp_constr (loc_of_txt (Longident.Ldot (Lident "Stdcompat__pervasives", "result")), []))) } | Ldot (Lident "Hashtbl", "statistics") -> { type_decl with ptype_manifest = Some (core_type_of_desc (Ptyp_constr (loc_of_txt (Longident.Ldot (Lident "Stdcompat__hashtbl_ext", "statistics")), []))) } | Ldot (Lapply (Ldot (Lident "Hashtbl", "MakeSeeded"), Lident "H"), "t") -> { type_decl with ptype_manifest = Some (core_type_of_desc (Ptyp_constr (loc_of_txt (Longident.Ldot (Lapply (Ldot (Lident "Stdcompat__hashtbl_ext", "MakeSeeded"), Lident "H"), "t")), type_decl.ptype_params |> List.map fst))) } | _ -> (* match type_decl.ptype_manifest with | Some ( { ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Lident "bytes" }, args) } as core_type) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__init", "bytes") }, args) in let ptype_manifest = Some { core_type with ptyp_desc } in { type_decl with ptype_manifest } | _ ->*) let ptype_params = remove_injectivity type_decl.ptype_params in let ptype_manifest = match type_decl.ptype_manifest with | None -> None | Some { ptyp_desc = Parsetree.Ptyp_constr ({ txt = Lident name }, _) } when name = type_decl.ptype_name.txt -> None | Some { ptyp_desc = Parsetree.Ptyp_constr ({ txt = Ldot (module_name', name) }, _) } when name = type_decl.ptype_name.txt && module_name = module_name' -> None | Some ( { ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Lident "bytes" }, args) } as core_type) -> let ptyp_desc = Parsetree.Ptyp_constr ({ loc; txt = Ldot (Lident "Stdcompat__init", "bytes") }, args) in Some { core_type with ptyp_desc } | Some ptype_manifest -> Some (compat_core_type ~module_name ptype_manifest) in { type_decl with ptype_params; ptype_manifest; ptype_kind = compat_type_kind ~module_name type_decl.ptype_kind } let compat_prim ~version prim = match prim with | ["caml_create_string"] -> if Interface_tools.Version.compare version { major = 3; minor = 8; patch = 0 } >= 0 then ["caml_create_string"] else ["create_string"] | ["%string_safe_set"] | ["%string_unsafe_set"] | ["%identity"] -> prim | ["caml_blit_string"] | ["caml_fill_string"] -> if Interface_tools.Version.compare version { major = 3; minor = 8; patch = 0 } >= 0 then prim @ ["noalloc"] else if prim = ["caml_blit_string"] then ["blit_string"; "noalloc"] else ["fill_string"; "noalloc"] | ["%raise_notrace"] -> ["%raise"] | _ -> [] let compat_value_description ~module_name ~version (value_description : Parsetree.value_description) = { value_description with pval_prim = compat_prim ~version value_description.pval_prim; pval_type = compat_core_type ~module_name value_description.pval_type; pval_attributes = []; } let rec compat_signature_item ~module_name ~reference_version ~version (item : Parsetree.signature_item) = match item.psig_desc with | Psig_type (rec_flag, type_decl) -> let type_decl = type_decl |> List.map (compat_type_declaration ~module_name) in let item = { item with psig_desc = Parsetree.Psig_type (rec_flag, type_decl) } in item | Psig_value value_desc -> let value_desc = compat_value_description ~module_name ~version value_desc in { item with psig_desc = Psig_value value_desc} | Psig_module module_declaration -> let module_name = Longident.Ldot (module_name, Option.get module_declaration.pmd_name.txt) in let pmd_type = module_declaration.pmd_type |> compat_module_type ~module_name ~reference_version ~version in { item with psig_desc = Psig_module { module_declaration with pmd_type }} | Psig_modtype module_type_declaration -> let pmtd_type = module_type_declaration.pmtd_type |> Interface_tools.Option.map @@ compat_module_type ~module_name ~reference_version ~version in { item with psig_desc = Psig_modtype { module_type_declaration with pmtd_type }} | _ -> item and compat_module_type ~module_name ~reference_version ~version (module_type : Parsetree.module_type) = match module_type.pmty_desc with | Pmty_ident ({ txt = Ldot (Lident "Hashtbl", "SeededHashedType") } as longident) -> let longident = { longident with txt = if module_name = Ldot (Lident "Hashtbl", "MakeSeeded") then Longident.Lident "SeededHashedType" else Longident.Ldot (Lident "Stdcompat__hashtbl", "SeededHashedType") } in { module_type with pmty_desc = Pmty_ident longident } | Pmty_signature signature -> let signature = List.map (compat_signature_item ~module_name ~reference_version ~version) signature in { module_type with pmty_desc = Pmty_signature signature } | Pmty_functor (Named (var, arg), body) -> let arg = Interface_tools.Option.map (compat_module_type ~module_name ~reference_version ~version) (Some arg) in let module_name = Longident.Lapply (module_name, Lident (Option.get var.txt)) in let body = compat_module_type ~module_name ~reference_version ~version body in { module_type with pmty_desc = Pmty_functor (Named (var, Option.get arg), body) } | Pmty_alias ident -> compat_module_type ~module_name ~reference_version ~version (module_type_of_name reference_version ident.txt) | _ -> module_type (* Pprintast.signature formatter [item] *) let rec make_version_range is_equal versions = match versions with | [] -> [] | (real, version, item) :: tail -> match make_version_range is_equal tail with | (real', version', item') :: tail when real == real' && is_equal ~version item ~version' item' -> (real', version', item') :: tail | tail -> (real, version, item) :: tail let is_prim_isomorphic kind p p' = match kind with | Ignore_attributes -> true | Attributes_equal -> List.equal String.equal p p' let is_value_description_isomorphic kind (value_desc : Parsetree.value_description) (value_desc' : Parsetree.value_description) = Name.equal value_desc.pval_name value_desc'.pval_name && is_core_type_isomorphic kind value_desc.pval_type value_desc'.pval_type && is_prim_isomorphic kind value_desc.pval_prim value_desc'.pval_prim && is_attributes_isomorphic kind value_desc.pval_attributes value_desc'.pval_attributes let rec is_module_type_desc_isomorphic kind ~version (module_type_desc : Parsetree.module_type_desc) ~version' (module_type_desc' : Parsetree.module_type_desc) = match module_type_desc, module_type_desc' with | Pmty_ident ident, Pmty_ident ident' -> ident.txt = ident'.txt | Pmty_signature s, Pmty_signature s' -> List.equal (is_signature_item_isomorphic kind ~version ~version') s s' | Pmty_alias ident, Pmty_alias ident' -> (kind = Ignore_attributes || ident.txt = ident'.txt) && is_module_type_isomorphic kind ~version (module_type_of_name version ident.txt) ~version' (module_type_of_name version ident'.txt) | (Pmty_alias _, _ | _, Pmty_alias _) when kind = Attributes_equal -> false | Pmty_alias ident, _ -> is_module_type_isomorphic kind ~version (module_type_of_name version ident.txt) ~version' (module_type_of_desc module_type_desc') | _, Pmty_alias ident' -> is_module_type_isomorphic kind ~version (module_type_of_desc module_type_desc) ~version' (module_type_of_name version ident'.txt) | Pmty_functor (Named (x, arg), body), Pmty_functor (Named (x', arg'), body') -> Option.get x.txt = Option.get x'.txt && Interface_tools.Option.equal (is_module_type_isomorphic kind ~version ~version') (Some arg) (Some arg') && is_module_type_isomorphic kind ~version body ~version' body' | Pmty_with _, Pmty_with _ -> true | Pmty_typeof _, Pmty_typeof _ -> true | _ -> false and is_module_type_isomorphic kind ~version (module_type : Parsetree.module_type) ~version' (module_type' : Parsetree.module_type) = is_module_type_desc_isomorphic kind ~version module_type.pmty_desc ~version' module_type'.pmty_desc && is_attributes_isomorphic kind module_type.pmty_attributes module_type'.pmty_attributes and is_module_declaration_isomorphic kind ~version (module_declaration : Parsetree.module_declaration) ~version' (module_declaration' : Parsetree.module_declaration) = Option.get module_declaration.pmd_name.txt = Option.get module_declaration'.pmd_name.txt && is_module_type_isomorphic kind ~version module_declaration.pmd_type ~version' module_declaration'.pmd_type && is_attributes_isomorphic kind module_declaration.pmd_attributes module_declaration'.pmd_attributes and is_module_type_declaration_isomorphic kind ~version (module_type_declaration : Parsetree.module_type_declaration) ~version' (module_type_declaration' : Parsetree.module_type_declaration) = Name.equal module_type_declaration.pmtd_name module_type_declaration'.pmtd_name && Interface_tools.Option.equal (is_module_type_isomorphic kind ~version ~version') module_type_declaration.pmtd_type module_type_declaration'.pmtd_type && is_attributes_isomorphic kind module_type_declaration.pmtd_attributes module_type_declaration'.pmtd_attributes and is_extension_constructor_isomorphic kind ~version (extension_constructor : Parsetree.extension_constructor) ~version' (extension_constructor' : Parsetree.extension_constructor) = extension_constructor.pext_name.txt = extension_constructor'.pext_name.txt and is_type_exception_isomorphic kind ~version (type_exception : Parsetree.type_exception) ~version' (type_exception' : Parsetree.type_exception) = is_extension_constructor_isomorphic kind ~version type_exception.ptyexn_constructor ~version' type_exception'.ptyexn_constructor and is_signature_item_isomorphic kind ~version (item : Parsetree.signature_item) ~version' (item' : Parsetree.signature_item) = match item.psig_desc, item'.psig_desc with | Psig_type (rec_flag, type_decl), Psig_type (rec_flag', type_decl') -> let block = { Type_declaration_block.rec_flag; type_decl } in let block' = { Type_declaration_block.rec_flag = rec_flag'; type_decl = type_decl' } in Type_declaration_block.is_isomorphic kind block block' | Psig_value value_desc, Psig_value value_desc' -> is_value_description_isomorphic kind value_desc value_desc' | Psig_module module_declaration, Psig_module module_declaration' -> is_module_declaration_isomorphic kind ~version module_declaration ~version' module_declaration' | Psig_modtype module_type_declaration, Psig_modtype module_type_declaration' -> is_module_type_declaration_isomorphic kind ~version module_type_declaration ~version' module_type_declaration' | Psig_exception extension_constructor, Psig_exception extension_constructor' -> is_type_exception_isomorphic kind ~version extension_constructor ~version' extension_constructor' | Psig_typext type_extension, Psig_typext type_extension' -> true | _ -> false let find_prim_opt version pval_name prim = let modules : Longident.t list = [Lident "Pervasives"] in let modules : Longident.t list = if Interface_tools.Version.compare version { major = 4; minor = 6; patch = 0 } >= 0 then Ldot (Lident "Array", "Floatarray") :: modules else modules in modules |> List.find_map @@ fun module_name -> let externals = get_externals module_name version in match StringHashtbl.find_opt externals prim with | None -> None | Some value_desc' -> Some { value_desc' with pval_name } let rec fake_module_type ~module_name ~reference_version ~version (module_type : Parsetree.module_type) = match module_type.pmty_desc with | Pmty_signature s -> let s = s |> List.map @@ fake_signature_item ~module_name ~reference_version ~version in { module_type with pmty_desc = Pmty_signature s } | Pmty_functor (Named (var, arg), body) -> let arg = fake_module_type ~module_name ~reference_version ~version arg in let body = fake_module_type ~module_name ~reference_version ~version body in { module_type with pmty_desc = Pmty_functor (Named (var, arg), body) } | _ -> module_type and fake_signature_item ~module_name ~reference_version ~version (item : Parsetree.signature_item) = match item.psig_desc with | Psig_value ({ pval_prim = prim :: _ } as value_desc) -> begin match find_prim_opt version value_desc.pval_name prim with | None -> compat_signature_item ~module_name ~reference_version ~version { item with psig_desc = Psig_value { value_desc with pval_prim = [] }} | Some value_desc -> { item with psig_desc = Psig_value value_desc } end | _ -> compat_signature_item ~module_name ~reference_version ~version item let version_signature_item ~reference_version ~module_name ~signatures (item : Parsetree.signature_item) = match item.psig_desc with | Psig_type (_rec_flag, type_decl) -> let block = { Type_declaration_block.rec_flag = Recursive; type_decl } in let first_type_name = Type_declaration_block.get_first_type_name block in Some (signatures |> List.map (fun (version, (s : Signature.t)) -> let real, type_decl = let block' = String.Map.find_opt first_type_name s.types in match if first_type_name = "lexbuf" then block' else Interface_tools.Option.filter (Type_declaration_block.is_isomorphic Ignore_attributes block) block' with | None -> false, type_decl |> List.map @@ compat_type_declaration ~module_name | Some block' -> true, block'.type_decl |> List.map @@ qualify_type_decl ~module_name in (real, version, { item with psig_desc = Psig_type (Recursive, type_decl) }))) | Psig_value value_desc -> Some (signatures |> List.map (fun (version, (s : Signature.t)) -> let real, value_desc' = match Interface_tools.Option.filter (fun (real, value_desc') -> is_value_description_isomorphic Ignore_attributes value_desc value_desc') @@ match String.Map.find_opt value_desc.pval_name.txt s.values with | None -> begin match value_desc.pval_prim with | [] -> None | prim :: _ -> match find_prim_opt version value_desc.pval_name prim with | None -> None | Some value_desc' -> Some (false, value_desc') end | Some value_desc' -> Some (true, value_desc') with | Some (real, value_desc') -> real, value_desc' | None -> false, compat_value_description ~module_name ~version value_desc in real, version, { item with psig_desc = Psig_value value_desc' })) | Psig_module module_declaration -> Some (signatures |> List.map (fun (version, (s : Signature.t)) -> let real, module_declaration' = match match String.Map.find_opt (Option.get module_declaration.pmd_name.txt) s.modules with | None -> None | Some module_declaration' -> if is_module_declaration_isomorphic Ignore_attributes ~version:reference_version module_declaration ~version':version module_declaration' then let module_declaration' = if Interface_tools.Version.compare version { major = 4; minor = 2; patch = 0 } >= 0 then { module_declaration with pmd_type = { pmty_desc = Pmty_alias { loc = Location.none; txt = Ldot (module_name, (Option.get module_declaration.pmd_name.txt)) }; pmty_loc = Location.none; pmty_attributes = [] }} else module_declaration' in Some (true, module_declaration') else None with | None -> let pmd_type = fake_module_type ~module_name ~reference_version ~version module_declaration.pmd_type in false, { module_declaration with pmd_type } | Some (real, module_declaration') -> real, module_declaration' in real, version, { item with psig_desc = Psig_module module_declaration' })) | Psig_modtype module_type_declaration -> Some (signatures |> List.map (fun (version, (s : Signature.t)) -> let real, module_type_declaration' = match String.Map.find_opt module_type_declaration.pmtd_name.txt s.module_types with | Some module_type_declaration' when is_module_type_declaration_isomorphic Ignore_attributes ~version:reference_version module_type_declaration ~version':version module_type_declaration' -> true, module_type_declaration' | _ -> let pmtd_type = module_type_declaration.pmtd_type |> Interface_tools.Option.map @@ compat_module_type ~module_name ~reference_version ~version in let module_type_declaration' = { module_type_declaration with pmtd_type } in false, module_type_declaration' in real, version, { item with psig_desc = Psig_modtype module_type_declaration' })) | Psig_exception extension_constructor -> Some ([true, reference_version, item]) | _ -> None let rec last_real_version versions = match versions with | [] | [None, _, _] -> assert false | [Some version, _, item] | (Some version, _, item) :: (None, _, _) :: _ -> version, item | _ :: tail -> last_real_version tail let compare_versioned_signature versions versions' = try let version, (item : Parsetree.signature_item) = last_real_version versions in let version', (item' : Parsetree.signature_item) = last_real_version versions' in match item.psig_desc, item'.psig_desc with | Psig_value _, Psig_value _ -> - Interface_tools.Version.compare version version' | _, Psig_value _ -> -1 | Psig_value _, _ -> 1 | _ -> 0 with _ -> prerr_endline "EMPTY!"; 0 let value_item (item : Parsetree.signature_item) = match item.psig_desc with | Psig_value _ -> true | _ -> false let rec consume_similar_versions last_real_version version item versions = match versions with | (real', version', item') :: tail when is_signature_item_isomorphic Attributes_equal ~version item ~version' item' && ((last_real_version <> None) = real' || value_item item) -> let last_real_version = if real' then Some version' else last_real_version in consume_similar_versions last_real_version version' item tail | tail -> (last_real_version, version, item), tail let rec gather_similar_versions versions = match versions with | [] -> [] | (real, version, item) :: tail -> let last_real_version = if real then Some version else None in let head', tail' = consume_similar_versions last_real_version version item tail in head' :: (gather_similar_versions tail') let type_of_desc ptyp_desc : Parsetree.core_type = Ast_helper.Typ.mk ptyp_desc let format_block block sub formatter item = Format.fprintf formatter "\ @@BEGIN_%s@@@.\ %a@.\ @@END_%s@@@.\ " block sub item block let format_block_prefix prefix block sub formatter item = format_block (prefix ^ "_" ^ block) sub formatter item let format_with block = format_block_prefix "WITH" block let format_without block = format_block_prefix "WITHOUT" block let format_ver prefix ver = format_block_prefix prefix (Interface_tools.Version.to_string ~sep:"_" ver) let format_before ver = format_ver "BEFORE" ver let format_from ver = format_ver "FROM" ver let format_without block sub formatter item = format_block ("WITHOUT_" ^ block) sub formatter item let format_with_without block sub formatter item_with item_without = format_with block sub formatter item_with; format_without block sub formatter item_without let format_from_before ver formatter sub_from item_from sub_before item_before = format_from ver sub_from formatter item_from; format_before ver sub_before formatter item_before let attributed_decl (decl : Parsetree.type_declaration) = decl.ptype_attributes <> [] let gadt_decl (decl : Parsetree.type_declaration) = match decl.ptype_kind with | Ptype_variant constructors -> List.exists (fun (constructor : Parsetree.constructor_declaration) -> constructor.pcd_res <> None) constructors | _ -> false let remove_gadt (decl : Parsetree.type_declaration) = match decl.ptype_kind with | Ptype_variant constructors -> let constructors = List.map (fun (constructor : Parsetree.constructor_declaration) -> { constructor with pcd_res = None }) constructors in { decl with ptype_kind = Ptype_variant constructors } | _ -> decl (* let make_rebind ~module_name (constructor : Parsetree.extension_constructor) = { constructor with pext_kind = Pext_rebind { loc = Location.none; txt = Longident.Ldot (module_name, constructor.pext_name.txt)}} *) let has_injective_param (decl : Parsetree.type_declaration) = List.exists (fun (_, (_, i)) -> i = Asttypes.Injective) decl.ptype_params let remove_injective_param (decl : Parsetree.type_declaration) = { decl with ptype_params = remove_injectivity decl.ptype_params } let remove_attributes (decl : Parsetree.type_declaration) = { decl with ptype_attributes = [] } let is_private (decl : Parsetree.type_declaration) = decl.ptype_private = Private let make_public (decl : Parsetree.type_declaration) = { decl with ptype_private = Public } let rec format_sig_type formatter ((recursive : Asttypes.rec_flag), (decls : Parsetree.type_declaration list)) = if List.exists has_injective_param decls then begin let decls' = List.map remove_injective_param decls in format_from_before (Interface_tools.Version.mk 4 12 0) formatter Pprintast.signature [Ast_helper.Sig.type_ recursive decls] format_sig_type (recursive, decls') end else if List.exists attributed_decl decls then begin let decls' = List.map remove_attributes decls in format_from_before (Interface_tools.Version.mk 4 02 0) formatter Pprintast.signature [Ast_helper.Sig.type_ recursive decls] format_sig_type (recursive, decls') end else if List.exists gadt_decl decls then begin let decls' = List.map remove_gadt decls in format_from_before (Interface_tools.Version.mk 4 00 0) formatter Pprintast.signature [Ast_helper.Sig.type_ recursive decls] format_sig_type (recursive, decls') end else if List.exists is_private decls then begin let decls' = List.map make_public decls in format_from_before (Interface_tools.Version.mk 3 11 0) formatter Pprintast.signature [Ast_helper.Sig.type_ recursive decls] format_sig_type (recursive, decls') end else Pprintast.signature formatter [Ast_helper.Sig.type_ recursive decls] let rec format_default_item ~module_name formatter (item : Parsetree.signature_item) = match item.psig_desc with | Psig_type (rec_flag, [{ ptype_name = { txt = "result" }} as type_decl]) -> let ptyp_desc = Parsetree.Ptyp_constr ( { txt = Ldot (Lident "Result", "result"); loc = Location.none }, [type_of_desc (Ptyp_var "a"); type_of_desc (Ptyp_var "b")]) in let manifest = type_of_desc ptyp_desc in let type_decl' = { type_decl with ptype_manifest = Some manifest } in format_with_without "UCHAR_PKG" format_sig_type formatter (rec_flag, [type_decl']) (rec_flag, [type_decl]) | Psig_type (rec_flag, [{ ptype_name = { txt = "t" }} as type_decl]) when module_name = Longident.Lident "Uchar" -> let ptyp_desc = Parsetree.Ptyp_constr ( { txt = Ldot (Lident "Uchar", "t"); loc = Location.none }, []) in let manifest = type_of_desc ptyp_desc in let type_decl' = { type_decl with ptype_manifest = Some manifest } in format_with_without "UCHAR_PKG" format_sig_type formatter (rec_flag, [type_decl']) (rec_flag, [type_decl]) | Psig_type (rec_flag, [{ ptype_name = { txt = "t" }} as type_decl]) when module_name = Longident.Lident "Either" -> let ptyp_desc = Parsetree.Ptyp_constr ( { txt = Ldot (Lident "Stdcompat__init", "either"); loc = Location.none }, List.map fst type_decl.ptype_params) in let manifest = type_of_desc ptyp_desc in let type_decl = { type_decl with ptype_manifest = Some manifest } in let psig_desc = Parsetree.Psig_type (rec_flag, [type_decl]) in let result_item = { item with psig_desc } in Pprintast.signature formatter [result_item] | Psig_type (_, _) when module_name = Longident.Lident "List" || module_name = Longident.Lident "ListLabels" -> Format.fprintf formatter "\ @@BEGIN_FROM_4_03_0@@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @@END_FROM_4_03_0@@ @@BEGIN_BEFORE_4_03_0@@ type 'a t = 'a list @@END_BEFORE_4_03_0@@" | Psig_type (_, _) when module_name = Longident.Lident "Seq" -> Format.fprintf formatter "\ type 'a t = unit -> 'a node and 'a node = 'a Stdcompat__init.seq_node = | Nil | Cons of 'a * 'a t" | Psig_type (_, [{ ptype_name = { txt }; ptype_manifest = Some t; ptype_kind = Ptype_open }]) -> Format.fprintf formatter "\ @@BEGIN_FROM_4_02_0@@ type %s = %a = .. @@END_FROM_4_02_0@@ @@BEGIN_BEFORE_4_02_0@@ type %s = %a @@END_BEFORE_4_02_0@@" txt Pprintast.core_type t txt Pprintast.core_type t | Psig_type (_, [{ ptype_name = { txt }; ptype_kind = Ptype_open }]) -> Format.fprintf formatter "\ @@BEGIN_FROM_4_02_0@@ type %s = .. @@END_FROM_4_02_0@@ @@BEGIN_BEFORE_4_02_0@@ type %s @@END_BEFORE_4_02_0@@" txt txt | Psig_type (recursive, decls) -> format_sig_type formatter (recursive, decls) | Psig_value { pval_name = { txt = "ifprintf"; _ }; _ } when module_name = Lident "Printf" -> Format.fprintf formatter "\ @@BEGIN_FROM_4_03_0@@ val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a (** @@since 4.03.0: val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a *) @@END_FROM_4_03_0@@ @@BEGIN_BEFORE_4_03_0@@ @@BEGIN_FROM_3_10_0@@ val ifprintf : 'b -> ('a, 'b, unit) format -> 'a @@END_FROM_3_10_0@@ @@BEGIN_BEFORE_3_10_0@@ val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a @@END_BEFORE_3_10_0@@ @@END_BEFORE_4_03_0@@" | Psig_value { pval_name = { txt = "ikfprintf"; _ }; _ } when module_name = Lident "Printf" -> Format.fprintf formatter "\ @@BEGIN_FROM_4_03_0@@ val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a (** @@since 4.03.0: val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a *) @@END_FROM_4_03_0@@ @@BEGIN_BEFORE_4_03_0@@ @@BEGIN_FROM_4_01_0@@ val ikfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b @@END_FROM_4_01_0@@ @@BEGIN_BEFORE_4_01_0@@ val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a @@END_BEFORE_4_01_0@@ @@END_BEFORE_4_03_0@@" | Psig_module module_declaration when match module_declaration.pmd_type.pmty_desc with Pmty_alias _ -> false | _ -> true -> Format.fprintf formatter "@[module %s :@ @[%a@]@]" (Option.get module_declaration.pmd_name.txt) (format_default_module_type ~module_name) module_declaration.pmd_type | Psig_modtype module_type_declaration -> Format.fprintf formatter "@[module type %s =@ @[%a@]@]" module_type_declaration.pmtd_name.txt (format_default_module_type ~module_name) (Option.get module_type_declaration.pmtd_type) (* | Psig_typext type_extension -> let type_extension = { type_extension with ptyext_constructors = List.map (make_rebind ~module_name) type_extension.ptyext_constructors } in Format.fprintf formatter "%a" Pprintast.signature [{ item with psig_desc = Psig_typext type_extension }] | Psig_exception type_exception -> let type_exception = { type_exception with ptyexn_constructor = make_rebind ~module_name type_exception.ptyexn_constructor } in Format.fprintf formatter "%a" Pprintast.signature [{ item with psig_desc = Psig_exception type_exception }] *) | _ -> Format.fprintf formatter "%a" Pprintast.signature [item] and format_default_module_type ~module_name formatter (module_type : Parsetree.module_type) = match module_type.pmty_desc with | Pmty_ident ident -> Format.fprintf formatter "%s" (string_of_longident ident.txt) | Pmty_signature signature -> Format.fprintf formatter "@[sig@ %a@ end@]" (Format.pp_print_list ~pp_sep:Format.pp_print_space (format_default_item ~module_name)) signature | Pmty_functor (Named (var, arg), body) -> Format.fprintf formatter "@[functor (%s : %a) ->@ %a@]" (Option.get var.txt) (format_default_module_type ~module_name) arg (format_default_module_type ~module_name) body | _ -> failwith "Not implemented" let item_name module_name (item : Parsetree.signature_item) = let name = match item.psig_desc with | Psig_type (rec_flag, type_decl :: _) -> type_decl.ptype_name.txt | Psig_value value_desc -> value_desc.pval_name.txt | Psig_module module_declaration -> Option.get module_declaration.pmd_name.txt | Psig_modtype module_type_declaration -> module_type_declaration.pmtd_name.txt | Psig_exception extension_constructor -> extension_constructor.ptyexn_constructor.pext_name.txt | _ -> assert false in Printf.sprintf "%s.%s" (string_of_longident module_name) name let add_self_type_manifest_to_type_decl ~(module_name : Longident.t) (type_decl : Parsetree.type_declaration) = match type_decl.ptype_manifest with | None -> let module_name : Longident.t = match module_name with | Lapply (Ldot (Lident "Hashtbl", "MakeSeeded"), Lident "H") -> Lapply (Ldot (Lident "Stdcompat__hashtbl_ext", "MakeSeeded"), Lident "H") | _ -> module_name in { type_decl with ptype_manifest = let params = type_decl.ptype_params |> List.map fst in Some (Ast_helper.Typ.constr ({ loc = Location.none; txt = Ldot (module_name, type_decl.ptype_name.txt) }) params)} | Some manifest -> type_decl let rec add_self_type_manifest ~module_name (item : Parsetree.signature_item) = match item.psig_desc with | Psig_type (rec_flag, type_decl_list) -> let type_decl_list = type_decl_list |> List.map (add_self_type_manifest_to_type_decl ~module_name) in { item with psig_desc = Psig_type (rec_flag, type_decl_list) } | Psig_value _ | Psig_modtype _ | Psig_exception _ -> item | Psig_module module_declaration -> let module_name : Longident.t = Ldot (module_name, Option.get module_declaration.pmd_name.txt) in { item with psig_desc = Psig_module { module_declaration with pmd_type = module_declaration.pmd_type |> (add_self_type_manifest_to_module_type ~module_name) }} (* | Psig_modtype module_type_declaration -> { item with psig_desc = Psig_modtype { module_type_declaration with pmtd_type = module_type_declaration.pmtd_type |> Option.map (add_self_type_manifest_to_module_type ~module_name) }} *) | _ -> assert false and add_self_type_manifest_to_module_type ~module_name (module_type : Parsetree.module_type) = match module_type.pmty_desc with | Pmty_signature signature -> let signature = signature |> List.map (add_self_type_manifest ~module_name) in { module_type with pmty_desc = Pmty_signature signature } | Pmty_functor (Named (var, arg), body) -> (* let arg = arg |> Option.map (add_self_type_manifest_to_module_type ~module_name) in *) let module_name : Longident.t = Lapply (module_name, Lident (Option.get var.txt)) in let body = body |> add_self_type_manifest_to_module_type ~module_name in { module_type with pmty_desc = Pmty_functor (Named (var, arg), body) } | Pmty_with (ty, cstr) -> { module_type with pmty_desc = Pmty_with (add_self_type_manifest_to_module_type ~module_name ty, cstr) } | _ -> module_type let print_signature_item ~(module_name : Longident.t) real formatter (item : Parsetree.signature_item) = if real <> None || module_name = Lident "Hashtbl" || module_name = Lident "Set" || module_name = Lident "Map" || module_name = Lident "Weak" then let self_item = add_self_type_manifest ~module_name item in format_default_item ~module_name formatter self_item else format_default_item ~module_name formatter item let format_versioned_signature ~module_name ~version_high ~version_low ~reference_version formatter versions = match versions with | [] -> assert false | [real, last_version, item] -> Format.fprintf formatter "%a@." (print_signature_item ~module_name real) item; let item_name = item_name module_name item in begin match real with | None -> () | Some real_version -> if Interface_tools.Version.equal real_version last_version then Format.fprintf formatter "(** Alias for {!%s} *)@.@." item_name else Format.fprintf formatter "(** @[@since %s:@ %a@] *)@.@." (Interface_tools.Version.to_string real_version) Pprintast.signature [item] end | (real, last_version, item) :: next :: tail -> format_from last_version (print_signature_item ~module_name real) formatter item; let rec format_tail version next tail = let format formatter tail = let (real, last_version, item) = next in match tail with | [] -> Format.fprintf formatter "%a" (print_signature_item ~module_name real) item | next :: tail -> format_from last_version (print_signature_item ~module_name real) formatter item; format_tail last_version next tail in format_before version format formatter tail in format_tail last_version next tail; let format_doc formatter versions = let format_doc_version (real, _version, item) = match real with | None -> () | Some real_version -> Format.fprintf formatter "@[@since %s:@ %a@]@." (Interface_tools.Version.to_string real_version) Pprintast.signature [item] in List.iter format_doc_version versions in Format.fprintf formatter "(** @[%a@] *)@.@." format_doc versions let generate channel module_name versions = let module_name = Longident.Lident module_name in let signatures = versions |> List.map @@ fun version -> let version = Interface_tools.Version.of_string version in let signature = module_type_of_name version module_name |> signature_of_module_type in version, signature in let reference_version, reference_signature = match signatures with | first :: _ -> first | _ -> failwith "No reference version" in let signatures = signatures |> List.map @@ fun (version, s) -> version, Signature.of_parsetree s in let versioned_signature = reference_signature |> List.filter_map @@ version_signature_item ~reference_version ~module_name ~signatures in let version_high, _ = List.hd signatures in let version_low, _ = List.last signatures in let formatter = Format.formatter_of_out_channel channel in Format.fprintf formatter "module type S = sig@."; versioned_signature |> List.map gather_similar_versions |> List.sort compare_versioned_signature |> List.iter @@ format_versioned_signature ~module_name ~version_high ~version_low ~reference_version formatter; Format.fprintf formatter "end@." (* let mli_filenames = argv |> Array.to_list |> List.tl in let signatures = mli_filenames |> List.map read_interface in let main_signature, other_signatures = match signatures with | [] -> failwith "No mli file given" | main_signature :: other_signatures -> main_signature, other_signatures in main_signature |> List.iter @@ format_signature_item Format.std_formatter *) let do_module versions module_name = print_endline module_name; let target = Printf.sprintf "../stdcompat__%s_s.mli.in" (String.lowercase_ascii module_name) in print_endline target; Out_channel.with_open_text target (fun channel -> generate channel module_name versions) let main _argv = let modules = ["Atomic"; "Arg"; "Array"; "ArrayLabels"; "Bool"; "Buffer"; "Bytes"; "BytesLabels"; "Callback"; "Char"; "Complex"; "Digest"; "Domain"; "Either"; "Ephemeron"; "Filename"; "Float"; "Format"; "Fun"; "Gc"; "Hashtbl"; "Int32"; "Int64"; "Lazy"; "Lexing"; "List"; "ListLabels"; "Map"; "Marshal"; "MoreLabels"; "Nativeint"; "Obj"; "Oo"; "Option"; "Parsing"; "Printexc"; "Printf"; "Queue"; "Random"; "Result"; "Scanf"; "Seq"; "Set"; "Stack"; "StdLabels"; "String"; "StringLabels"; "Sys"; "Uchar"; "Weak"; "In_channel"; "Out_channel"; "Unit"] in let versions = ["5.2"; "5.1"; "5.0"; "4.14"; "4.13"; "4.12"; "4.11"; "4.10"; "4.09"; "4.08"; "4.07"; "4.06"; "4.05"; "4.04"; "4.03"; "4.02"; "4.01"; "4.00"; "3.12"; "3.11"; "3.10"; "3.09"; "3.08"; "3.07"] in List.iter (do_module versions) modules let () = if not !Sys.interactive then try Sys.argv |> main with e -> prerr_endline (Printexc.to_string e); Printexc.print_backtrace stderr; exit 1 ocaml-stdcompat-20~git20240529/interface_generator/interface_generator.mli000066400000000000000000000000001463722102200266220ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interface_generator/interface_tools.ml000066400000000000000000000071061463722102200256410ustar00rootroot00000000000000module Option = struct type 'a t = 'a option let map f o = match o with | None -> None | Some x -> Some (f x) let equal p o o' = match o, o' with | None, None -> true | Some x, Some y -> p x y | Some _, None | None, Some _ -> false let exists p o = match o with | None -> false | Some x -> p x let some x = Some x let iter f o = match o with | None -> () | Some x -> f x let filter p o = match o with | Some x when p x -> o | None | Some _ -> None end module Version = struct type t = { major : int; minor : int; patch : int; } let mk major minor patch = { major; minor; patch } let compare (v : t) (v' : t) = compare v v' let equal (v : t) (v' : t) = v = v' let hash (v : t) = Hashtbl.hash v let of_string version_line = let index = match String.rindex version_line ' ' with | space_index -> space_index + 1 | exception Not_found -> 0 in let version = String.sub version_line index (String.length version_line - index) in let major, minor = match String.split_on_char '.' version with | [major; minor; _patch] -> major, minor | [major; minor] -> major, minor | _ -> assert false in { major = int_of_string major; minor = int_of_string minor; patch = 0; } (* let of_command_line command_line = let version_command_line = Printf.sprintf "%s -version" command_line in let in_channel = Unix.open_process_in version_command_line in let version_line = try_close ~close:(fun () -> assert (in_channel |> Unix.close_process_in = Unix.WEXITED 0)) @@ fun () -> input_line in_channel in of_version_line version_line *) let to_string ?(sep = ".") ?(include_patch = true) { major; minor; patch } = let major_minor = if major >= 5 then Printf.sprintf "%d%s%d" major sep minor else Printf.sprintf "%d%s%.2d" major sep minor in if include_patch then Printf.sprintf "%s%s%d" major_minor sep patch else major_minor end let signature_of_in_channel ?filename in_channel = let lexbuf = in_channel |> Lexing.from_channel in filename |> Option.iter (Lexing.set_filename lexbuf); lexbuf |> Parse.interface (* module Interpreter = struct type t = { command_line : string; version : Version.t; } let of_command_line command_line = let version = Version.of_command_line command_line in { command_line; version } end *) module Buffer = struct include Buffer let add_channel_no_wait buffer in_channel size = let bytes = Bytes.create size in let read = input in_channel bytes 0 size in Buffer.add_subbytes buffer bytes 0 read; read let add_channel_to_the_end ?(chunk_size = 4096) ?(continue = fun () -> true) buffer in_channel = while add_channel_no_wait buffer in_channel chunk_size <> 0 && continue () do () done let suffix_of_length buffer len = sub buffer (length buffer - len) len let has_suffix buffer suffix = length buffer >= String.length suffix && suffix_of_length buffer (String.length suffix) = suffix end module String = struct include String let suffix_of_length s len = sub s (length s - len) len let has_suffix s ~suffix = length s >= length suffix && suffix_of_length s (length suffix) = suffix let prefix_of_length s len = sub s 0 len let has_prefix s ~prefix = length s >= length prefix && prefix_of_length s (length prefix) = prefix let suffix_from s pos = sub s pos (length s - pos) end ocaml-stdcompat-20~git20240529/interface_generator/interface_tools.mli000066400000000000000000000031421463722102200260060ustar00rootroot00000000000000module Option : sig type 'a t = 'a option val map : ('a -> 'b) -> 'a option -> 'b option val equal : ('a -> 'b -> bool) -> 'a option -> 'b option -> bool val exists : ('a -> bool) -> 'a option -> bool val some : 'a -> 'a option val iter : ('a -> unit) -> 'a option -> unit val filter : ('a -> bool) -> 'a option -> 'a option end module Version : sig type t = { major : int; minor : int; patch : int; } val mk : int -> int -> int -> t val compare : t -> t -> int val equal : t -> t -> bool val hash : t -> int val of_string : string -> t (* val of_command_line : string -> t *) val to_string : ?sep:string -> ?include_patch:bool -> t -> string end val signature_of_in_channel : ?filename:string -> in_channel -> Parsetree.signature (* module Interpreter : sig type t = { command_line : string; version : Version.t; } val of_command_line : string -> t end *) module Buffer : sig include module type of (struct include Buffer end) val add_channel_no_wait : Buffer.t -> in_channel -> int -> int val add_channel_to_the_end : ?chunk_size:int -> ?continue:(unit -> bool) -> Buffer.t -> in_channel -> unit val suffix_of_length : Buffer.t -> int -> string val has_suffix : Buffer.t -> string -> bool end module String : sig include module type of (struct include String end) val suffix_of_length : string -> int -> string val has_suffix : string -> suffix:string -> bool val prefix_of_length : string -> int -> string val has_prefix : string -> prefix:string -> bool val suffix_from : string -> int -> string end ocaml-stdcompat-20~git20240529/interfaces/000077500000000000000000000000001463722102200202405ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.07/000077500000000000000000000000001463722102200206275ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.07/arg.mli000066400000000000000000000014201463722102200221000ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) and key = string and doc = string and usage_msg = string and anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val current : int ref ocaml-stdcompat-20~git20240529/interfaces/3.07/array.mli000066400000000000000000000025411463722102200224520ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "make_vect" external create : int -> 'a -> 'a array = "make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.07/arrayLabels.mli000066400000000000000000000027131463722102200235760ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "make_vect" external create : int -> 'a -> 'a array = "make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.07/buffer.mli000066400000000000000000000006631463722102200226100ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/callback.mli000066400000000000000000000001231463722102200230620ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/char.mli000066400000000000000000000003611463722102200222470ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/3.07/complex.mli000066400000000000000000000006021463722102200227770ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/3.07/digest.mli000066400000000000000000000003741463722102200226150ustar00rootroot00000000000000type t = string val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string ocaml-stdcompat-20~git20240529/interfaces/3.07/filename.mli000066400000000000000000000010051463722102200231060ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : string -> string -> string val open_temp_file : ?mode:open_flag list -> string -> string -> (string * out_channel) val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/3.07/format.mli000066400000000000000000000126721463722102200226320ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.07/gc.mli000066400000000000000000000022511463722102200217230ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int } and control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int } external stat : unit -> stat = "gc_stat" external counters : unit -> (float * float * float) = "gc_counters" external get : unit -> control = "gc_get" external set : control -> unit = "gc_set" external minor : unit -> unit = "gc_minor" external major_slice : int -> int = "gc_major_slice" external major : unit -> unit = "gc_major" external full_major : unit -> unit = "gc_full_major" external compact : unit -> unit = "gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/genlex.mli000066400000000000000000000003011463722102200226060ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/3.07/hashtbl.mli000066400000000000000000000031521463722102200227600ustar00rootroot00000000000000type ('a, 'b) t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> 'a -> 'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "hash_univ_param" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.07/int32.mli000066400000000000000000000023661463722102200223000ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "int32_of_float" external to_float : int32 -> float = "int32_to_float" external of_string : string -> int32 = "int32_of_string" val to_string : int32 -> string type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "int32_format" ocaml-stdcompat-20~git20240529/interfaces/3.07/int64.mli000066400000000000000000000031521463722102200222770ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "int64_of_float" external to_float : int64 -> float = "int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "int64_bits_of_float" external float_of_bits : int64 -> float = "int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "int64_format" ocaml-stdcompat-20~git20240529/interfaces/3.07/lazy.mli000066400000000000000000000003041463722102200223060ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined val force : 'a t -> 'a val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/3.07/lexing.mli000066400000000000000000000027231463722102200226240ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/3.07/list.mli000066400000000000000000000036751463722102200223200ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.07/listLabels.mli000066400000000000000000000040311463722102200234260ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.07/map.mli000066400000000000000000000016631463722102200221150ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key and +'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b end ocaml-stdcompat-20~git20240529/interfaces/3.07/marshal.mli000066400000000000000000000006701463722102200227640ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/3.07/moreLabels.mli000066400000000000000000000113271463722102200234230ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> key:'a -> data:'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c module type HashedType = Hashtbl.HashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "hash_univ_param" "noalloc" end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt end end ocaml-stdcompat-20~git20240529/interfaces/3.07/nativeint.mli000066400000000000000000000032411463722102200233330ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "nativeint_of_float" external to_float : nativeint -> float = "nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/3.07/obj.mli000066400000000000000000000016231463722102200221060ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "obj_tag" external set_tag : t -> int -> unit = "obj_set_tag" external size : t -> int = "%obj_size" external truncate : t -> int -> unit = "obj_truncate" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external new_block : int -> int -> t = "obj_block" external dup : t -> t = "obj_dup" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/3.07/oo.mli000066400000000000000000000002631463722102200217500ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.label val public_method_label : string -> CamlinternalOO.label ocaml-stdcompat-20~git20240529/interfaces/3.07/parsing.mli000066400000000000000000000017041463722102200227770ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error type parser_env and parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/pervasives.mli000066400000000000000000000163561463722102200235340ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "power_float" "pow" "float" external sqrt : float -> float = "sqrt_float" "sqrt" "float" external exp : float -> float = "exp_float" "exp" "float" external log : float -> float = "log_float" "log" "float" external log10 : float -> float = "log10_float" "log10" "float" external cos : float -> float = "cos_float" "cos" "float" external sin : float -> float = "sin_float" "sin" "float" external tan : float -> float = "tan_float" "tan" "float" external acos : float -> float = "acos_float" "acos" "float" external asin : float -> float = "asin_float" "asin" "float" external atan : float -> float = "atan_float" "atan" "float" external atan2 : float -> float -> float = "atan2_float" "atan2" "float" external cosh : float -> float = "cosh_float" "cosh" "float" external sinh : float -> float = "sinh_float" "sinh" "float" external tanh : float -> float = "tanh_float" "tanh" "float" external ceil : float -> float = "ceil_float" "ceil" "float" external floor : float -> float = "floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external mod_float : float -> float -> float = "fmod_float" "fmod" "float" external frexp : float -> (float * int) = "frexp_float" external ldexp : float -> int -> float = "ldexp_float" external modf : float -> (float * float) = "modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel and out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 external string_of_format : ('a, 'b, 'c, 'd) format4 -> string = "%identity" external format_of_string : ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd) format4 = "%identity" val (^^) : ('a, 'b, 'c, 'd) format4 -> ('d, 'b, 'c, 'e) format4 -> ('a, 'b, 'c, 'e) format4 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/printexc.mli000066400000000000000000000001441463722102200231650ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.07/printf.mli000066400000000000000000000007501463722102200226360ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val scan_format : string -> int -> (string -> int -> 'a) -> ('b -> 'c -> int -> 'a) -> ('d -> int -> 'a) -> (int -> 'a) -> 'a ocaml-stdcompat-20~git20240529/interfaces/3.07/queue.mli000066400000000000000000000006501463722102200224570ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/random.mli000066400000000000000000000012701463722102200226120ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/scanf.mli000066400000000000000000000014251463722102200224260ustar00rootroot00000000000000module Scanning : sig type scanbuf val stdib : scanbuf val from_string : string -> scanbuf val from_file : string -> scanbuf val from_file_bin : string -> scanbuf val from_function : (unit -> char) -> scanbuf val from_channel : in_channel -> scanbuf val end_of_input : scanbuf -> bool val beginning_of_input : scanbuf -> bool end exception Scan_failure of string val bscanf : Scanning.scanbuf -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val fscanf : in_channel -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val sscanf : string -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val scanf : ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val kscanf : Scanning.scanbuf -> (Scanning.scanbuf -> exn -> 'a) -> ('b, Scanning.scanbuf, 'a) format -> 'b -> 'a ocaml-stdcompat-20~git20240529/interfaces/3.07/set.mli000066400000000000000000000032741463722102200221330ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt end ocaml-stdcompat-20~git20240529/interfaces/3.07/sort.mli000066400000000000000000000002471463722102200223240ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.07/stack.mli000066400000000000000000000004131463722102200224350ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/stdLabels.mli000066400000000000000000000116701463722102200232540ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "make_vect" external create : int -> 'a -> 'a array = "make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/3.07/stream.mli000066400000000000000000000012611463722102200226250ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.07/string.mli000066400000000000000000000025201463722102200226370ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.07/stringLabels.mli000066400000000000000000000026001463722102200237610ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.07/sys.mli000066400000000000000000000024661463722102200221600ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "sys_file_exists" external remove : string -> unit = "sys_remove" external rename : string -> string -> unit = "sys_rename" external getenv : string -> string = "sys_getenv" external command : string -> int = "sys_system_command" external time : unit -> float = "sys_time" external chdir : string -> unit = "sys_chdir" external getcwd : unit -> string = "sys_getcwd" external readdir : string -> string array = "sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/3.07/weak.mli000066400000000000000000000024631463722102200222660ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data and t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t and t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/3.08/000077500000000000000000000000001463722102200206305ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.08/arg.mli000066400000000000000000000015231463722102200221050ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/3.08/array.mli000066400000000000000000000025531463722102200224560ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.08/arrayLabels.mli000066400000000000000000000027251463722102200236020ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.08/buffer.mli000066400000000000000000000007621463722102200226110ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/callback.mli000066400000000000000000000001231463722102200230630ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/char.mli000066400000000000000000000003611463722102200222500ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/3.08/complex.mli000066400000000000000000000006021463722102200230000ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/3.08/digest.mli000066400000000000000000000004011463722102200226050ustar00rootroot00000000000000type t = string val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string ocaml-stdcompat-20~git20240529/interfaces/3.08/filename.mli000066400000000000000000000010051463722102200231070ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : string -> string -> string val open_temp_file : ?mode:open_flag list -> string -> string -> (string * out_channel) val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/3.08/format.mli000066400000000000000000000131331463722102200226240ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.08/gc.mli000066400000000000000000000024651463722102200217330ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/genlex.mli000066400000000000000000000003011463722102200226070ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/3.08/hashtbl.mli000066400000000000000000000033141463722102200227610ustar00rootroot00000000000000type ('a, 'b) t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> 'a -> 'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.08/int32.mli000066400000000000000000000026241463722102200222760ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/3.08/int64.mli000066400000000000000000000032101463722102200222730ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/3.08/lazy.mli000066400000000000000000000003041463722102200223070ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined val force : 'a t -> 'a val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/3.08/lexing.mli000066400000000000000000000027231463722102200226250ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/3.08/list.mli000066400000000000000000000036751463722102200223210ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.08/listLabels.mli000066400000000000000000000040311463722102200234270ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.08/map.mli000066400000000000000000000023411463722102200221100ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end ocaml-stdcompat-20~git20240529/interfaces/3.08/marshal.mli000066400000000000000000000006751463722102200227720ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/3.08/moreLabels.mli000066400000000000000000000123411463722102200234210ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> key:'a -> data:'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int module type HashedType = Hashtbl.HashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end end ocaml-stdcompat-20~git20240529/interfaces/3.08/nativeint.mli000066400000000000000000000032651463722102200233420ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/3.08/obj.mli000066400000000000000000000017351463722102200221130ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external truncate : t -> int -> unit = "caml_obj_truncate" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/3.08/oo.mli000066400000000000000000000002571463722102200217540ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/3.08/parsing.mli000066400000000000000000000017051463722102200230010ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/pervasives.mli000066400000000000000000000165261463722102200235340ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd) format4 -> string external format_of_string : ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd) format4 = "%identity" val (^^) : ('a, 'b, 'c, 'd) format4 -> ('d, 'b, 'c, 'e) format4 -> ('a, 'b, 'c, 'e) format4 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/printexc.mli000066400000000000000000000001441463722102200231660ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.08/printf.mli000066400000000000000000000007501463722102200226370ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val scan_format : string -> int -> (string -> int -> 'a) -> ('b -> 'c -> int -> 'a) -> ('d -> int -> 'a) -> (int -> 'a) -> 'a ocaml-stdcompat-20~git20240529/interfaces/3.08/queue.mli000066400000000000000000000006501463722102200224600ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/random.mli000066400000000000000000000012701463722102200226130ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/scanf.mli000066400000000000000000000014251463722102200224270ustar00rootroot00000000000000module Scanning : sig type scanbuf val stdib : scanbuf val from_string : string -> scanbuf val from_file : string -> scanbuf val from_file_bin : string -> scanbuf val from_function : (unit -> char) -> scanbuf val from_channel : in_channel -> scanbuf val end_of_input : scanbuf -> bool val beginning_of_input : scanbuf -> bool end exception Scan_failure of string val bscanf : Scanning.scanbuf -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val fscanf : in_channel -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val sscanf : string -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val scanf : ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val kscanf : Scanning.scanbuf -> (Scanning.scanbuf -> exn -> 'a) -> ('b, Scanning.scanbuf, 'a) format -> 'b -> 'a ocaml-stdcompat-20~git20240529/interfaces/3.08/set.mli000066400000000000000000000034241463722102200221310ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end ocaml-stdcompat-20~git20240529/interfaces/3.08/sort.mli000066400000000000000000000002471463722102200223250ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.08/stack.mli000066400000000000000000000004131463722102200224360ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/stdLabels.mli000066400000000000000000000123061463722102200232520ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/3.08/stream.mli000066400000000000000000000012611463722102200226260ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.08/string.mli000066400000000000000000000025431463722102200226450ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.08/stringLabels.mli000066400000000000000000000026731463722102200237740ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.08/sys.mli000066400000000000000000000025501463722102200221530ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/3.08/weak.mli000066400000000000000000000024651463722102200222710ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/3.09/000077500000000000000000000000001463722102200206315ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.09/arg.mli000066400000000000000000000015231463722102200221060ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/3.09/array.mli000066400000000000000000000025531463722102200224570ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.09/arrayLabels.mli000066400000000000000000000027251463722102200236030ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.09/buffer.mli000066400000000000000000000007621463722102200226120ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/callback.mli000066400000000000000000000001231463722102200230640ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/char.mli000066400000000000000000000003611463722102200222510ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/3.09/complex.mli000066400000000000000000000006021463722102200230010ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/3.09/digest.mli000066400000000000000000000004011463722102200226060ustar00rootroot00000000000000type t = string val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string ocaml-stdcompat-20~git20240529/interfaces/3.09/filename.mli000066400000000000000000000010401463722102200231070ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : string -> string -> string val open_temp_file : ?mode:open_flag list -> string -> string -> (string * out_channel) val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/3.09/format.mli000066400000000000000000000131331463722102200226250ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.09/gc.mli000066400000000000000000000024651463722102200217340ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/genlex.mli000066400000000000000000000003011463722102200226100ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/3.09/hashtbl.mli000066400000000000000000000033141463722102200227620ustar00rootroot00000000000000type ('a, 'b) t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> 'a -> 'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.09/int32.mli000066400000000000000000000026241463722102200222770ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/3.09/int64.mli000066400000000000000000000032101463722102200222740ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/3.09/lazy.mli000066400000000000000000000003041463722102200223100ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined val force : 'a t -> 'a val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/3.09/lexing.mli000066400000000000000000000027231463722102200226260ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/3.09/list.mli000066400000000000000000000036751463722102200223220ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.09/listLabels.mli000066400000000000000000000040311463722102200234300ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.09/map.mli000066400000000000000000000023411463722102200221110ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end ocaml-stdcompat-20~git20240529/interfaces/3.09/marshal.mli000066400000000000000000000006751463722102200227730ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/3.09/moreLabels.mli000066400000000000000000000123411463722102200234220ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> key:'a -> data:'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int module type HashedType = Hashtbl.HashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end end ocaml-stdcompat-20~git20240529/interfaces/3.09/nativeint.mli000066400000000000000000000032651463722102200233430ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/3.09/obj.mli000066400000000000000000000017351463722102200221140ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external truncate : t -> int -> unit = "caml_obj_truncate" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/3.09/oo.mli000066400000000000000000000002571463722102200217550ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/3.09/parsing.mli000066400000000000000000000017051463722102200230020ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/pervasives.mli000066400000000000000000000165261463722102200235350ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd) format4 -> string external format_of_string : ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd) format4 = "%identity" val (^^) : ('a, 'b, 'c, 'd) format4 -> ('d, 'b, 'c, 'e) format4 -> ('a, 'b, 'c, 'e) format4 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/printexc.mli000066400000000000000000000001441463722102200231670ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.09/printf.mli000066400000000000000000000021231463722102200226340ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b type index external index_of_int : int -> index = "%identity" val scan_format : string -> 'a array -> index -> int -> (index -> string -> int -> 'b) -> (index -> 'c -> 'd -> int -> 'b) -> (index -> 'e -> int -> 'b) -> (index -> int -> 'b) -> (index -> ('f, 'g, 'h, 'i) format4 -> int -> 'b) -> 'b val sub_format : (string -> int) -> (string -> int -> char -> int) -> char -> string -> int -> int val summarize_format_type : string -> string val kapr : (string -> Obj.t array -> 'a) -> string -> 'a ocaml-stdcompat-20~git20240529/interfaces/3.09/queue.mli000066400000000000000000000006501463722102200224610ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/random.mli000066400000000000000000000012701463722102200226140ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/scanf.mli000066400000000000000000000020031463722102200224210ustar00rootroot00000000000000module Scanning : sig type scanbuf val stdib : scanbuf val from_string : string -> scanbuf val from_file : string -> scanbuf val from_file_bin : string -> scanbuf val from_function : (unit -> char) -> scanbuf val from_channel : in_channel -> scanbuf val end_of_input : scanbuf -> bool val beginning_of_input : scanbuf -> bool val name_of_input : scanbuf -> string end exception Scan_failure of string val bscanf : Scanning.scanbuf -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val fscanf : in_channel -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val sscanf : string -> ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val scanf : ('a, Scanning.scanbuf, 'b) format -> 'a -> 'b val kscanf : Scanning.scanbuf -> (Scanning.scanbuf -> exn -> 'a) -> ('b, Scanning.scanbuf, 'a) format -> 'b -> 'a val bscanf_format : Scanning.scanbuf -> ('a, 'b, 'c, 'd) format4 -> (('a, 'b, 'c, 'd) format4 -> 'e) -> 'e val sscanf_format : string -> ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd) format4 ocaml-stdcompat-20~git20240529/interfaces/3.09/set.mli000066400000000000000000000034241463722102200221320ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end ocaml-stdcompat-20~git20240529/interfaces/3.09/sort.mli000066400000000000000000000002471463722102200223260ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.09/stack.mli000066400000000000000000000004131463722102200224370ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/stdLabels.mli000066400000000000000000000123061463722102200232530ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/3.09/stream.mli000066400000000000000000000012611463722102200226270ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.09/string.mli000066400000000000000000000025431463722102200226460ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.09/stringLabels.mli000066400000000000000000000026731463722102200237750ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.09/sys.mli000066400000000000000000000025501463722102200221540ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/3.09/weak.mli000066400000000000000000000024651463722102200222720ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/3.10/000077500000000000000000000000001463722102200206215ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.10/arg.mli000066400000000000000000000015231463722102200220760ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/3.10/array.mli000066400000000000000000000025531463722102200224470ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.10/arrayLabels.mli000066400000000000000000000027251463722102200235730ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.10/buffer.mli000066400000000000000000000007621463722102200226020ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/callback.mli000066400000000000000000000001231463722102200230540ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/char.mli000066400000000000000000000003611463722102200222410ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/3.10/complex.mli000066400000000000000000000006021463722102200227710ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/3.10/digest.mli000066400000000000000000000004011463722102200225760ustar00rootroot00000000000000type t = string val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string ocaml-stdcompat-20~git20240529/interfaces/3.10/filename.mli000066400000000000000000000010401463722102200230770ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : string -> string -> string val open_temp_file : ?mode:open_flag list -> string -> string -> (string * out_channel) val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/3.10/format.mli000066400000000000000000000132321463722102200226150ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.10/gc.mli000066400000000000000000000024651463722102200217240ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/genlex.mli000066400000000000000000000003011463722102200226000ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/3.10/hashtbl.mli000066400000000000000000000033141463722102200227520ustar00rootroot00000000000000type ('a, 'b) t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> 'a -> 'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.10/int32.mli000066400000000000000000000026241463722102200222670ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/3.10/int64.mli000066400000000000000000000032101463722102200222640ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/3.10/lazy.mli000066400000000000000000000003041463722102200223000ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined val force : 'a t -> 'a val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/3.10/lexing.mli000066400000000000000000000027231463722102200226160ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/3.10/list.mli000066400000000000000000000036751463722102200223120ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.10/listLabels.mli000066400000000000000000000040311463722102200234200ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.10/map.mli000066400000000000000000000023411463722102200221010ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end ocaml-stdcompat-20~git20240529/interfaces/3.10/marshal.mli000066400000000000000000000006751463722102200227630ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/3.10/moreLabels.mli000066400000000000000000000123411463722102200234120ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> key:'a -> data:'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int module type HashedType = Hashtbl.HashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end end ocaml-stdcompat-20~git20240529/interfaces/3.10/nativeint.mli000066400000000000000000000032651463722102200233330ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/3.10/obj.mli000066400000000000000000000017351463722102200221040ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external truncate : t -> int -> unit = "caml_obj_truncate" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/3.10/oo.mli000066400000000000000000000002571463722102200217450ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/3.10/parsing.mli000066400000000000000000000017051463722102200227720ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/pervasives.mli000066400000000000000000000167131463722102200235230ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/printexc.mli000066400000000000000000000001441463722102200231570ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.10/printf.mli000066400000000000000000000047511463722102200226350ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val ifprintf : 'a -> ('b, 'a, unit) format -> 'b val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b module CamlinternalPr : sig module Sformat : sig type index val index_of_int : int -> index external int_of_index : index -> int = "%identity" external unsafe_index_of_int : int -> index = "%identity" val succ_index : index -> index val sub : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> index -> int -> string val to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external length : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int = "%string_length" external get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_safe_get" external unsafe_to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string = "%identity" external unsafe_get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_unsafe_get" end module Tformat : sig type ac = { mutable ac_rglr: int ; mutable ac_skip: int ; mutable ac_rdrs: int } val ac_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ac val sub_format : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int) -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char -> int) -> char -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> int val summarize_format_type : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string val scan_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g array -> Sformat.index -> int -> (Sformat.index -> string -> int -> 'h) -> (Sformat.index -> 'i -> 'j -> int -> 'h) -> (Sformat.index -> 'k -> int -> 'h) -> (Sformat.index -> int -> 'h) -> (Sformat.index -> ('l, 'm, 'n, 'o, 'p, 'q) format6 -> int -> 'h) -> 'h val kapr : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> Obj.t array -> 'g) -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g end end ocaml-stdcompat-20~git20240529/interfaces/3.10/queue.mli000066400000000000000000000006501463722102200224510ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/random.mli000066400000000000000000000012701463722102200226040ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/scanf.mli000066400000000000000000000022331463722102200224160ustar00rootroot00000000000000module Scanning : sig type scanbuf val stdib : scanbuf val from_string : string -> scanbuf val from_file : string -> scanbuf val from_file_bin : string -> scanbuf val from_function : (unit -> char) -> scanbuf val from_channel : in_channel -> scanbuf val end_of_input : scanbuf -> bool val beginning_of_input : scanbuf -> bool val name_of_input : scanbuf -> string end exception Scan_failure of string type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.scanbuf, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c val bscanf : Scanning.scanbuf -> ('a, 'b, 'c, 'd) scanner val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.scanbuf -> (Scanning.scanbuf -> exn -> 'a) -> ('b, 'c, 'd, 'a) scanner val bscanf_format : Scanning.scanbuf -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ocaml-stdcompat-20~git20240529/interfaces/3.10/set.mli000066400000000000000000000034241463722102200221220ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end ocaml-stdcompat-20~git20240529/interfaces/3.10/sort.mli000066400000000000000000000002471463722102200223160ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.10/stack.mli000066400000000000000000000004131463722102200224270ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/stdLabels.mli000066400000000000000000000123061463722102200232430ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/3.10/stream.mli000066400000000000000000000012611463722102200226170ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.10/string.mli000066400000000000000000000025431463722102200226360ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.10/stringLabels.mli000066400000000000000000000026731463722102200237650ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.10/sys.mli000066400000000000000000000026511463722102200221460ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/3.10/weak.mli000066400000000000000000000024651463722102200222620ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/3.11/000077500000000000000000000000001463722102200206225ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.11/arg.mli000066400000000000000000000015231463722102200220770ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/3.11/array.mli000066400000000000000000000025531463722102200224500ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.11/arrayLabels.mli000066400000000000000000000027251463722102200235740ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.11/buffer.mli000066400000000000000000000010461463722102200225770ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val blit : t -> int -> string -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/callback.mli000066400000000000000000000001231463722102200230550ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/char.mli000066400000000000000000000003611463722102200222420ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/3.11/complex.mli000066400000000000000000000006021463722102200227720ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/3.11/digest.mli000066400000000000000000000004011463722102200225770ustar00rootroot00000000000000type t = string val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string ocaml-stdcompat-20~git20240529/interfaces/3.11/filename.mli000066400000000000000000000011411463722102200231020ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?temp_dir:string -> string -> string -> (string * out_channel) val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/3.11/format.mli000066400000000000000000000132321463722102200226160ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.11/gc.mli000066400000000000000000000025301463722102200217160ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/genlex.mli000066400000000000000000000003011463722102200226010ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/3.11/hashtbl.mli000066400000000000000000000033141463722102200227530ustar00rootroot00000000000000type ('a, 'b) t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> 'a -> 'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.11/int32.mli000066400000000000000000000026241463722102200222700ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/3.11/int64.mli000066400000000000000000000032101463722102200222650ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/3.11/lazy.mli000066400000000000000000000003311463722102200223010ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/3.11/lexing.mli000066400000000000000000000027611463722102200226210ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/3.11/list.mli000066400000000000000000000036751463722102200223130ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.11/listLabels.mli000066400000000000000000000040311463722102200234210ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.11/map.mli000066400000000000000000000023411463722102200221020ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key -> 'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool end ocaml-stdcompat-20~git20240529/interfaces/3.11/marshal.mli000066400000000000000000000006751463722102200227640ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/3.11/moreLabels.mli000066400000000000000000000123411463722102200234130ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> key:'a -> data:'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int module type HashedType = Hashtbl.HashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val find : key -> 'a t -> 'a val remove : key -> 'a t -> 'a t val mem : key -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end end ocaml-stdcompat-20~git20240529/interfaces/3.11/nativeint.mli000066400000000000000000000032651463722102200233340ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/3.11/obj.mli000066400000000000000000000022071463722102200221000ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> int -> t = "caml_obj_add_offset" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/3.11/oo.mli000066400000000000000000000002571463722102200217460ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/3.11/parsing.mli000066400000000000000000000017421463722102200227740ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/pervasives.mli000066400000000000000000000167131463722102200235240ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/printexc.mli000066400000000000000000000004571463722102200231670ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/printf.mli000066400000000000000000000047511463722102200226360ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val ifprintf : 'a -> ('b, 'a, unit) format -> 'b val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b module CamlinternalPr : sig module Sformat : sig type index val index_of_int : int -> index external int_of_index : index -> int = "%identity" external unsafe_index_of_int : int -> index = "%identity" val succ_index : index -> index val sub : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> index -> int -> string val to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external length : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int = "%string_length" external get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_safe_get" external unsafe_to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string = "%identity" external unsafe_get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_unsafe_get" end module Tformat : sig type ac = { mutable ac_rglr: int ; mutable ac_skip: int ; mutable ac_rdrs: int } val ac_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ac val sub_format : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int) -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char -> int) -> char -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> int val summarize_format_type : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string val scan_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g array -> Sformat.index -> int -> (Sformat.index -> string -> int -> 'h) -> (Sformat.index -> 'i -> 'j -> int -> 'h) -> (Sformat.index -> 'k -> int -> 'h) -> (Sformat.index -> int -> 'h) -> (Sformat.index -> ('l, 'm, 'n, 'o, 'p, 'q) format6 -> int -> 'h) -> 'h val kapr : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> Obj.t array -> 'g) -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g end end ocaml-stdcompat-20~git20240529/interfaces/3.11/queue.mli000066400000000000000000000006501463722102200224520ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/random.mli000066400000000000000000000012701463722102200226050ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/scanf.mli000066400000000000000000000022331463722102200224170ustar00rootroot00000000000000module Scanning : sig type scanbuf val stdib : scanbuf val from_string : string -> scanbuf val from_file : string -> scanbuf val from_file_bin : string -> scanbuf val from_function : (unit -> char) -> scanbuf val from_channel : in_channel -> scanbuf val end_of_input : scanbuf -> bool val beginning_of_input : scanbuf -> bool val name_of_input : scanbuf -> string end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.scanbuf, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.scanbuf -> ('a, 'b, 'c, 'd) scanner val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.scanbuf -> (Scanning.scanbuf -> exn -> 'a) -> ('b, 'c, 'd, 'a) scanner val bscanf_format : Scanning.scanbuf -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ocaml-stdcompat-20~git20240529/interfaces/3.11/set.mli000066400000000000000000000034241463722102200221230ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end ocaml-stdcompat-20~git20240529/interfaces/3.11/sort.mli000066400000000000000000000002471463722102200223170ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.11/stack.mli000066400000000000000000000004131463722102200224300ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/stdLabels.mli000066400000000000000000000123061463722102200232440ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/3.11/stream.mli000066400000000000000000000012611463722102200226200ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.11/string.mli000066400000000000000000000025431463722102200226370ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.11/stringLabels.mli000066400000000000000000000026731463722102200237660ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.11/sys.mli000066400000000000000000000026511463722102200221470ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/3.11/weak.mli000066400000000000000000000024651463722102200222630ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/3.12/000077500000000000000000000000001463722102200206235ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/3.12/arg.mli000066400000000000000000000016251463722102200221030ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/3.12/array.mli000066400000000000000000000025531463722102200224510ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.12/arrayLabels.mli000066400000000000000000000027251463722102200235750ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/3.12/buffer.mli000066400000000000000000000010461463722102200226000ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val blit : t -> int -> string -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/callback.mli000066400000000000000000000001231463722102200230560ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/char.mli000066400000000000000000000003611463722102200222430ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/3.12/complex.mli000066400000000000000000000006021463722102200227730ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/3.12/digest.mli000066400000000000000000000004011463722102200226000ustar00rootroot00000000000000type t = string val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string ocaml-stdcompat-20~git20240529/interfaces/3.12/filename.mli000066400000000000000000000011411463722102200231030ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?temp_dir:string -> string -> string -> (string * out_channel) val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/3.12/format.mli000066400000000000000000000133661463722102200226270ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/3.12/gc.mli000066400000000000000000000025541463722102200217250ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/genlex.mli000066400000000000000000000003011463722102200226020ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/3.12/hashtbl.mli000066400000000000000000000033141463722102200227540ustar00rootroot00000000000000type ('a, 'b) t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> 'a -> 'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.12/int32.mli000066400000000000000000000026241463722102200222710ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/3.12/int64.mli000066400000000000000000000032101463722102200222660ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/3.12/lazy.mli000066400000000000000000000003311463722102200223020ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/3.12/lexing.mli000066400000000000000000000027611463722102200226220ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/3.12/list.mli000066400000000000000000000036751463722102200223140ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.12/listLabels.mli000066400000000000000000000040311463722102200234220ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.12/map.mli000066400000000000000000000046271463722102200221140ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/3.12/marshal.mli000066400000000000000000000006751463722102200227650ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/3.12/moreLabels.mli000066400000000000000000000147631463722102200234260ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val add : ('a, 'b) t -> key:'a -> data:'b -> unit val copy : ('a, 'b) t -> ('a, 'b) t val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int module type HashedType = Hashtbl.HashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int end val hash : 'a -> int external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end end ocaml-stdcompat-20~git20240529/interfaces/3.12/nativeint.mli000066400000000000000000000032651463722102200233350ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/3.12/obj.mli000066400000000000000000000022131463722102200220760ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/3.12/oo.mli000066400000000000000000000002571463722102200217470ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/3.12/parsing.mli000066400000000000000000000017421463722102200227750ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/pervasives.mli000066400000000000000000000172661463722102200235310ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/printexc.mli000066400000000000000000000004571463722102200231700ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/printf.mli000066400000000000000000000047511463722102200226370ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val ifprintf : 'a -> ('b, 'a, unit) format -> 'b val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b module CamlinternalPr : sig module Sformat : sig type index val index_of_int : int -> index external int_of_index : index -> int = "%identity" external unsafe_index_of_int : int -> index = "%identity" val succ_index : index -> index val sub : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> index -> int -> string val to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external length : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int = "%string_length" external get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_safe_get" external unsafe_to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string = "%identity" external unsafe_get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_unsafe_get" end module Tformat : sig type ac = { mutable ac_rglr: int ; mutable ac_skip: int ; mutable ac_rdrs: int } val ac_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ac val sub_format : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int) -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char -> int) -> char -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> int val summarize_format_type : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string val scan_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g array -> Sformat.index -> int -> (Sformat.index -> string -> int -> 'h) -> (Sformat.index -> 'i -> 'j -> int -> 'h) -> (Sformat.index -> 'k -> int -> 'h) -> (Sformat.index -> int -> 'h) -> (Sformat.index -> ('l, 'm, 'n, 'o, 'p, 'q) format6 -> int -> 'h) -> 'h val kapr : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> Obj.t array -> 'g) -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g end end ocaml-stdcompat-20~git20240529/interfaces/3.12/queue.mli000066400000000000000000000006501463722102200224530ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/random.mli000066400000000000000000000012701463722102200226060ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/scanf.mli000066400000000000000000000025571463722102200224310ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel val open_in : string -> in_channel val open_in_bin : string -> in_channel val close_in : in_channel -> unit val from_file : string -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'a) -> ('b, 'c, 'd, 'a) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ocaml-stdcompat-20~git20240529/interfaces/3.12/set.mli000066400000000000000000000034241463722102200221240ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end ocaml-stdcompat-20~git20240529/interfaces/3.12/sort.mli000066400000000000000000000002471463722102200223200ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/3.12/stack.mli000066400000000000000000000004131463722102200224310ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/stdLabels.mli000066400000000000000000000123061463722102200232450ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/3.12/stream.mli000066400000000000000000000012611463722102200226210ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/3.12/string.mli000066400000000000000000000025431463722102200226400ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.12/stringLabels.mli000066400000000000000000000026731463722102200237670ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/3.12/sys.mli000066400000000000000000000026511463722102200221500ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/3.12/weak.mli000066400000000000000000000024651463722102200222640ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.00/000077500000000000000000000000001463722102200206215ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.00/arg.mli000066400000000000000000000016251463722102200221010ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/4.00/array.mli000066400000000000000000000025531463722102200224470ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.00/arrayLabels.mli000066400000000000000000000027251463722102200235730ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.00/buffer.mli000066400000000000000000000010461463722102200225760ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val blit : t -> int -> string -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/callback.mli000066400000000000000000000001231463722102200230540ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/char.mli000066400000000000000000000003611463722102200222410ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.00/complex.mli000066400000000000000000000006021463722102200227710ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.00/digest.mli000066400000000000000000000004701463722102200226040ustar00rootroot00000000000000type t = string val compare : t -> t -> int val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.00/filename.mli000066400000000000000000000012571463722102200231110ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.00/format.mli000066400000000000000000000133661463722102200226250ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/4.00/gc.mli000066400000000000000000000025541463722102200217230ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/genlex.mli000066400000000000000000000003011463722102200226000ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.00/hashtbl.mli000066400000000000000000000066371463722102200227650ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.00/int32.mli000066400000000000000000000026241463722102200222670ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.00/int64.mli000066400000000000000000000032101463722102200222640ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.00/lazy.mli000066400000000000000000000004611463722102200223040ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.00/lexing.mli000066400000000000000000000027611463722102200226200ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.00/list.mli000066400000000000000000000040431463722102200223000ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.00/listLabels.mli000066400000000000000000000042031463722102200234210ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.00/map.mli000066400000000000000000000046271463722102200221120ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.00/marshal.mli000066400000000000000000000006751463722102200227630ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.00/moreLabels.mli000066400000000000000000000203731463722102200234160ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end end ocaml-stdcompat-20~git20240529/interfaces/4.00/nativeint.mli000066400000000000000000000032651463722102200233330ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.00/obj.mli000066400000000000000000000022131463722102200220740ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/4.00/oo.mli000066400000000000000000000002571463722102200217450ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.00/parsing.mli000066400000000000000000000017421463722102200227730ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/pervasives.mli000066400000000000000000000175511463722102200235240ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/printexc.mli000066400000000000000000000004571463722102200231660ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/printf.mli000066400000000000000000000047511463722102200226350ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val ifprintf : 'a -> ('b, 'a, unit) format -> 'b val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b module CamlinternalPr : sig module Sformat : sig type index val index_of_int : int -> index external int_of_index : index -> int = "%identity" external unsafe_index_of_int : int -> index = "%identity" val succ_index : index -> index val sub : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> index -> int -> string val to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external length : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int = "%string_length" external get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_safe_get" external unsafe_to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string = "%identity" external unsafe_get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_unsafe_get" end module Tformat : sig type ac = { mutable ac_rglr: int ; mutable ac_skip: int ; mutable ac_rdrs: int } val ac_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ac val sub_format : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int) -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char -> int) -> char -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> int val summarize_format_type : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string val scan_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g array -> Sformat.index -> int -> (Sformat.index -> string -> int -> 'h) -> (Sformat.index -> 'i -> 'j -> int -> 'h) -> (Sformat.index -> 'k -> int -> 'h) -> (Sformat.index -> int -> 'h) -> (Sformat.index -> ('l, 'm, 'n, 'o, 'p, 'q) format6 -> int -> 'h) -> 'h val kapr : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> Obj.t array -> 'g) -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g end end ocaml-stdcompat-20~git20240529/interfaces/4.00/queue.mli000066400000000000000000000006501463722102200224510ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/random.mli000066400000000000000000000012701463722102200226040ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/scanf.mli000066400000000000000000000026631463722102200224250ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.00/set.mli000066400000000000000000000034241463722102200221220ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) end ocaml-stdcompat-20~git20240529/interfaces/4.00/sort.mli000066400000000000000000000002471463722102200223160ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.00/stack.mli000066400000000000000000000004131463722102200224270ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/stdLabels.mli000066400000000000000000000125151463722102200232450ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/4.00/stream.mli000066400000000000000000000012611463722102200226170ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.00/string.mli000066400000000000000000000027401463722102200226350ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/4.00/stringLabels.mli000066400000000000000000000030741463722102200237610ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/4.00/sys.mli000066400000000000000000000026771463722102200221560ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val word_size : int val big_endian : bool val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/4.00/weak.mli000066400000000000000000000024651463722102200222620ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.01/000077500000000000000000000000001463722102200206225ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.01/arg.mli000066400000000000000000000021641463722102200221010ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (string * spec * string) list ref -> anon_fun -> string -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (string * spec * string) list ref -> anon_fun -> string -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/4.01/array.mli000066400000000000000000000025531463722102200224500ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.01/arrayLabels.mli000066400000000000000000000027251463722102200235740ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.01/buffer.mli000066400000000000000000000010461463722102200225770ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val sub : t -> int -> int -> string val blit : t -> int -> string -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_substring : t -> string -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/callback.mli000066400000000000000000000001231463722102200230550ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/char.mli000066400000000000000000000003611463722102200222420ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.01/complex.mli000066400000000000000000000006021463722102200227720ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.01/digest.mli000066400000000000000000000004701463722102200226050ustar00rootroot00000000000000type t = string val compare : t -> t -> int val string : string -> t val substring : string -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.01/filename.mli000066400000000000000000000012571463722102200231120ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.01/format.mli000066400000000000000000000144031463722102200226170ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit } val set_formatter_out_functions : formatter_out_functions -> unit val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) ocaml-stdcompat-20~git20240529/interfaces/4.01/gc.mli000066400000000000000000000025541463722102200217240ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/genlex.mli000066400000000000000000000003011463722102200226010ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.01/hashtbl.mli000066400000000000000000000066371463722102200227660ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.01/int32.mli000066400000000000000000000026241463722102200222700ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.01/int64.mli000066400000000000000000000032101463722102200222650ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.01/lazy.mli000066400000000000000000000004611463722102200223050ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.01/lexing.mli000066400000000000000000000027611463722102200226210ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (string -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.01/list.mli000066400000000000000000000040431463722102200223010ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.01/listLabels.mli000066400000000000000000000042031463722102200234220ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.01/map.mli000066400000000000000000000046271463722102200221130ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.01/marshal.mli000066400000000000000000000007141463722102200227560ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : string -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : string -> int -> int val total_size : string -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.01/moreLabels.mli000066400000000000000000000204751463722102200234220ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt end end ocaml-stdcompat-20~git20240529/interfaces/4.01/nativeint.mli000066400000000000000000000032651463722102200233340ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.01/obj.mli000066400000000000000000000022131463722102200220750ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val marshal : t -> string val unmarshal : string -> int -> (t * int) ocaml-stdcompat-20~git20240529/interfaces/4.01/oo.mli000066400000000000000000000002571463722102200217460ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.01/parsing.mli000066400000000000000000000017421463722102200227740ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/pervasives.mli000066400000000000000000000177201463722102200235230ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> string -> int -> int -> int val really_input : in_channel -> string -> int -> int -> unit val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> string -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/printexc.mli000066400000000000000000000010161463722102200231570ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string val get_callstack : int -> raw_backtrace ocaml-stdcompat-20~git20240529/interfaces/4.01/printf.mli000066400000000000000000000053301463722102200226300ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'a -> ('b, 'a, unit) format -> 'b val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ikfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b module CamlinternalPr : sig module Sformat : sig type index val index_of_int : int -> index external int_of_index : index -> int = "%identity" external unsafe_index_of_int : int -> index = "%identity" val succ_index : index -> index val add_int_index : int -> index -> index val sub : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> index -> int -> string val to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external length : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int = "%string_length" external get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_safe_get" external unsafe_to_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string = "%identity" external unsafe_get : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char = "%string_unsafe_get" end module Tformat : sig type ac = { mutable ac_rglr: int ; mutable ac_skip: int ; mutable ac_rdrs: int } val ac_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ac val count_printing_arguments_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int val sub_format : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int) -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> char -> int) -> char -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> int -> int val summarize_format_type : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string val scan_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g array -> Sformat.index -> int -> (Sformat.index -> string -> int -> 'h) -> (Sformat.index -> 'i -> 'j -> int -> 'h) -> (Sformat.index -> 'k -> int -> 'h) -> (Sformat.index -> int -> 'h) -> (Sformat.index -> ('l, 'm, 'n, 'o, 'p, 'q) format6 -> int -> 'h) -> 'h val kapr : (('a, 'b, 'c, 'd, 'e, 'f) format6 -> Obj.t array -> 'g) -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g end end ocaml-stdcompat-20~git20240529/interfaces/4.01/queue.mli000066400000000000000000000006501463722102200224520ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/random.mli000066400000000000000000000012701463722102200226050ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/scanf.mli000066400000000000000000000026631463722102200224260ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.01/set.mli000066400000000000000000000035221463722102200221220ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt end ocaml-stdcompat-20~git20240529/interfaces/4.01/sort.mli000066400000000000000000000002471463722102200223170ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list val array : ('a -> 'a -> bool) -> 'a array -> unit val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.01/stack.mli000066400000000000000000000004131463722102200224300ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/stdLabels.mli000066400000000000000000000125151463722102200232460ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/4.01/stream.mli000066400000000000000000000012611463722102200226200ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.01/string.mli000066400000000000000000000027401463722102200226360ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> int -> int -> string val fill : string -> int -> int -> char -> unit val blit : string -> int -> string -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> string -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/4.01/stringLabels.mli000066400000000000000000000030741463722102200237620ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : string -> int -> char -> unit = "%string_safe_set" external create : int -> string = "caml_create_string" val make : int -> char -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : string -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : string -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:string -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : string -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/4.01/sys.mli000066400000000000000000000027621463722102200221520ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val unix : bool val win32 : bool val cygwin : bool val word_size : int val big_endian : bool val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/4.01/weak.mli000066400000000000000000000024651463722102200222630ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.02/000077500000000000000000000000001463722102200206235ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.02/arg.mli000066400000000000000000000021631463722102200221010ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/4.02/array.mli000066400000000000000000000032041463722102200224430ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val iteri : (int -> 'a -> unit) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a external make_float : int -> float array = "caml_make_float_vect" val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.02/arrayLabels.mli000066400000000000000000000033021463722102200235650ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use ArrayLabels.make instead."] val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use ArrayLabels.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.02/buffer.mli000066400000000000000000000012261463722102200226000ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/bytes.mli000066400000000000000000000035461463722102200224640ustar00rootroot00000000000000external length : bytes -> int = "%string_length" external get : bytes -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes external unsafe_get : bytes -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string" "noalloc" ocaml-stdcompat-20~git20240529/interfaces/4.02/bytesLabels.mli000066400000000000000000000034771463722102200236120ustar00rootroot00000000000000external length : bytes -> int = "%string_length" external get : bytes -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int external unsafe_get : bytes -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.02/callback.mli000066400000000000000000000001231463722102200230560ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/char.mli000066400000000000000000000003611463722102200222430ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char type t = char val compare : t -> t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.02/complex.mli000066400000000000000000000006021463722102200227730ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.02/digest.mli000066400000000000000000000005671463722102200226150ustar00rootroot00000000000000type t = string val compare : t -> t -> int val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.02/filename.mli000066400000000000000000000014101463722102200231020ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.02/format.mli000066400000000000000000000162051463722102200226220ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val open_tbox : unit -> unit val close_tbox : unit -> unit val print_tbreak : int -> int -> unit val set_tab : unit -> unit val print_tab : unit -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit } val set_formatter_out_functions : formatter_out_functions -> unit val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_open_tbox : formatter -> unit -> unit val pp_close_tbox : formatter -> unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val pp_set_tab : formatter -> unit -> unit val pp_print_tab : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.set_formatter_out_functions instead."] val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.get_formatter_out_functions instead."] val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.pp_set_formatter_out_functions instead."] val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.pp_get_formatter_out_functions instead."] ocaml-stdcompat-20~git20240529/interfaces/4.02/gc.mli000066400000000000000000000025541463722102200217250ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/genlex.mli000066400000000000000000000003011463722102200226020ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.02/hashtbl.mli000066400000000000000000000066371463722102200227670ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.02/int32.mli000066400000000000000000000026241463722102200222710ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" external to_float : int32 -> float = "caml_int32_to_float" external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" external float_of_bits : int32 -> float = "caml_int32_float_of_bits" type t = int32 val compare : t -> t -> int external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.02/int64.mli000066400000000000000000000032101463722102200222660ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" external to_float : int64 -> float = "caml_int64_to_float" external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" external float_of_bits : int64 -> float = "caml_int64_float_of_bits" type t = int64 val compare : t -> t -> int external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.02/lazy.mli000066400000000000000000000010141463722102200223010ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] ocaml-stdcompat-20~git20240529/interfaces/4.02/lexing.mli000066400000000000000000000027571463722102200226270ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (bytes -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.02/list.mli000066400000000000000000000041331463722102200223020ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.02/listLabels.mli000066400000000000000000000042031463722102200234230ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.02/map.mli000066400000000000000000000046301463722102200221060ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.02/marshal.mli000066400000000000000000000011041463722102200227510ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_string" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.02/moreLabels.mli000066400000000000000000000206021463722102200234130ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.02/nativeint.mli000066400000000000000000000032651463722102200233350ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" external to_float : nativeint -> float = "caml_nativeint_to_float" external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.02/obj.mli000066400000000000000000000030301463722102200220740ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external set_tag : t -> int -> unit = "caml_obj_set_tag" external size : t -> int = "%obj_size" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int[@@ocaml.deprecated "Replaced by custom_tag."] val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val extension_name : 'a -> string val extension_id : 'a -> int val extension_slot : 'a -> t val marshal : t -> bytes[@@ocaml.deprecated "Use Marshal.to_bytes instead."] val unmarshal : bytes -> int -> (t * int)[@@ocaml.deprecated "Use Marshal.from_bytes and Marshal.total_size instead."] ocaml-stdcompat-20~git20240529/interfaces/4.02/oo.mli000066400000000000000000000002571463722102200217470ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.02/parsing.mli000066400000000000000000000017421463722102200227750ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/pervasives.mli000066400000000000000000000216311463722102200235200ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" external exp : float -> float = "caml_exp_float" "exp" "float" external log : float -> float = "caml_log_float" "log" "float" external log10 : float -> float = "caml_log10_float" "log10" "float" external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" external cos : float -> float = "caml_cos_float" "cos" "float" external sin : float -> float = "caml_sin_float" "sin" "float" external tan : float -> float = "caml_tan_float" "tan" "float" external acos : float -> float = "caml_acos_float" "acos" "float" external asin : float -> float = "caml_asin_float" "asin" "float" external atan : float -> float = "caml_atan_float" "atan" "float" external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" external cosh : float -> float = "caml_cosh_float" "cosh" "float" external sinh : float -> float = "caml_sinh_float" "sinh" "float" external tanh : float -> float = "caml_tanh_float" "tanh" "float" external ceil : float -> float = "caml_ceil_float" "ceil" "float" external floor : float -> float = "caml_floor_float" "floor" "float" external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : float -> int -> float = "caml_ldexp_float" external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : float -> fpclass = "caml_classify_float" val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/printexc.mli000066400000000000000000000023041463722102200231610ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.02/printf.mli000066400000000000000000000013601463722102200226300ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'a -> ('b, 'a, unit) format -> 'b val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ikfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/4.02/queue.mli000066400000000000000000000006501463722102200224530ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/random.mli000066400000000000000000000012701463722102200226060ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/scanf.mli000066400000000000000000000031551463722102200224240ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.02/set.mli000066400000000000000000000036221463722102200221240ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end ocaml-stdcompat-20~git20240529/interfaces/4.02/sort.mli000066400000000000000000000007321463722102200223170ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list[@@ocaml.deprecated "Use List.sort instead."] val array : ('a -> 'a -> bool) -> 'a array -> unit[@@ocaml.deprecated "Use Array.sort instead."] val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list[@@ocaml.deprecated "Use List.merge instead."] ocaml-stdcompat-20~git20240529/interfaces/4.02/stack.mli000066400000000000000000000004131463722102200224310ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/stdLabels.mli000066400000000000000000000167171463722102200232570ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module Bytes : sig external length : bytes -> int = "%string_length" external get : bytes -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int external unsafe_get : bytes -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" end ocaml-stdcompat-20~git20240529/interfaces/4.02/stream.mli000066400000000000000000000013201463722102200226150ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.02/string.mli000066400000000000000000000042021463722102200226320ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string" "noalloc"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] ocaml-stdcompat-20~git20240529/interfaces/4.02/stringLabels.mli000066400000000000000000000041671463722102200237670ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" [@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] ocaml-stdcompat-20~git20240529/interfaces/4.02/sys.mli000066400000000000000000000027621463722102200221530ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> float = "caml_sys_time" external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val unix : bool val win32 : bool val cygwin : bool val word_size : int val big_endian : bool val max_string_length : int val max_array_length : int type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int exception Break val catch_break : bool -> unit val ocaml_version : string ocaml-stdcompat-20~git20240529/interfaces/4.02/weak.mli000066400000000000000000000024651463722102200222640ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.03/000077500000000000000000000000001463722102200206245ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.03/arg.mli000066400000000000000000000021631463722102200221020ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/4.03/array.mli000066400000000000000000000040441463722102200224470ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.03/arrayLabels.mli000066400000000000000000000040671463722102200235770ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use ArrayLabels.make instead."] val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use ArrayLabels.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use ArrayLabels.create_float instead."] val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.03/buffer.mli000066400000000000000000000012261463722102200226010ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/bytes.mli000066400000000000000000000047151463722102200224640ustar00rootroot00000000000000external length : bytes -> int = "%string_length" external get : bytes -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes external unsafe_get : bytes -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.03/bytesLabels.mli000066400000000000000000000036071463722102200236060ustar00rootroot00000000000000external length : bytes -> int = "%string_length" external get : bytes -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int external unsafe_get : bytes -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.03/callback.mli000066400000000000000000000001231463722102200230570ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/char.mli000066400000000000000000000007761463722102200222560ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.03/complex.mli000066400000000000000000000006021463722102200227740ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.03/digest.mli000066400000000000000000000006221463722102200226060ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.03/ephemeron.mli000066400000000000000000000237231463722102200233200ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.03/filename.mli000066400000000000000000000014341463722102200231110ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.03/format.mli000066400000000000000000000203711463722102200226220ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit } val set_formatter_out_functions : formatter_out_functions -> unit val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.set_formatter_out_functions instead."] val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.get_formatter_out_functions instead."] val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.pp_set_formatter_out_functions instead."] val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.pp_get_formatter_out_functions instead."] val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] ocaml-stdcompat-20~git20240529/interfaces/4.03/gc.mli000066400000000000000000000032451463722102200217240ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free"[@@noalloc ] external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/genlex.mli000066400000000000000000000003011463722102200226030ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.03/hashtbl.mli000066400000000000000000000074371463722102200227670ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.03/int32.mli000066400000000000000000000032431463722102200222700ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.03/int64.mli000066400000000000000000000036271463722102200223030ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.03/lazy.mli000066400000000000000000000010141463722102200223020ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] ocaml-stdcompat-20~git20240529/interfaces/4.03/lexing.mli000066400000000000000000000027571463722102200226300ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (bytes -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.03/list.mli000066400000000000000000000041771463722102200223130ustar00rootroot00000000000000val length : 'a list -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.03/listLabels.mli000066400000000000000000000042771463722102200234370ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.03/map.mli000066400000000000000000000050461463722102200221110ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.03/marshal.mli000066400000000000000000000011041463722102200227520ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_string" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.03/moreLabels.mli000066400000000000000000000217341463722102200234230ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.03/nativeint.mli000066400000000000000000000035201463722102200233300ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.03/obj.mli000066400000000000000000000042041463722102200221010ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" external is_block : t -> bool = "caml_obj_is_block" external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int[@@ocaml.deprecated "Replaced by custom_tag."] val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes[@@ocaml.deprecated "Use Marshal.to_bytes instead."] val unmarshal : bytes -> int -> (t * int)[@@ocaml.deprecated "Use Marshal.from_bytes and Marshal.total_size instead."] module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.03/oo.mli000066400000000000000000000002571463722102200217500ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.03/parsing.mli000066400000000000000000000017421463722102200227760ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/pervasives.mli000066400000000000000000000235561463722102200235310ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/printexc.mli000066400000000000000000000023041463722102200231620ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.03/printf.mli000066400000000000000000000013221463722102200226270ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.03/queue.mli000066400000000000000000000006501463722102200224540ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/random.mli000066400000000000000000000012701463722102200226070ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/scanf.mli000066400000000000000000000035541463722102200224300ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.bscanf."] val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.kscanf."] ocaml-stdcompat-20~git20240529/interfaces/4.03/set.mli000066400000000000000000000036221463722102200221250ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end ocaml-stdcompat-20~git20240529/interfaces/4.03/sort.mli000066400000000000000000000007321463722102200223200ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list[@@ocaml.deprecated "Use List.sort instead."] val array : ('a -> 'a -> bool) -> 'a array -> unit[@@ocaml.deprecated "Use Array.sort instead."] val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list[@@ocaml.deprecated "Use List.merge instead."] ocaml-stdcompat-20~git20240529/interfaces/4.03/stack.mli000066400000000000000000000004731463722102200224400ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b ocaml-stdcompat-20~git20240529/interfaces/4.03/stdLabels.mli000066400000000000000000000176611463722102200232570ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module Bytes : sig external length : bytes -> int = "%string_length" external get : bytes -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int external unsafe_get : bytes -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] end ocaml-stdcompat-20~git20240529/interfaces/4.03/stream.mli000066400000000000000000000013201463722102200226160ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/string.mli000066400000000000000000000053661463722102200226470ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.03/stringLabels.mli000066400000000000000000000042751463722102200237700ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.03/sys.mli000066400000000000000000000037111463722102200221470ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.03/uchar.mli000066400000000000000000000006021463722102200224270ustar00rootroot00000000000000type t val min : t val max : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int val dump : Format.formatter -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.03/weak.mli000066400000000000000000000024651463722102200222650ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.04/000077500000000000000000000000001463722102200206255ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.04/arg.mli000066400000000000000000000021631463722102200221030ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref ocaml-stdcompat-20~git20240529/interfaces/4.04/array.mli000066400000000000000000000040441463722102200224500ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.04/arrayLabels.mli000066400000000000000000000040671463722102200236000ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use ArrayLabels.make instead."] val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use ArrayLabels.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use ArrayLabels.create_float instead."] val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.04/buffer.mli000066400000000000000000000012261463722102200226020ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/bytes.mli000066400000000000000000000046011463722102200224570ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.04/bytesLabels.mli000066400000000000000000000034731463722102200236100ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.04/callback.mli000066400000000000000000000001231463722102200230600ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/char.mli000066400000000000000000000007761463722102200222570ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.04/complex.mli000066400000000000000000000006021463722102200227750ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.04/digest.mli000066400000000000000000000006221463722102200226070ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.04/ephemeron.mli000066400000000000000000000237231463722102200233210ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.04/filename.mli000066400000000000000000000015451463722102200231150ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.04/format.mli000066400000000000000000000204441463722102200226240ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit } val set_formatter_out_functions : formatter_out_functions -> unit val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val pp_flush_formatter : formatter -> unit val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.set_formatter_out_functions instead."] val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.get_formatter_out_functions instead."] val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.pp_set_formatter_out_functions instead."] val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.pp_get_formatter_out_functions instead."] val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] ocaml-stdcompat-20~git20240529/interfaces/4.04/gc.mli000066400000000000000000000035221463722102200217230ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed"[@@noalloc ] external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free"[@@noalloc ] external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/genlex.mli000066400000000000000000000003011463722102200226040ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.04/hashtbl.mli000066400000000000000000000074371463722102200227700ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.04/int32.mli000066400000000000000000000032431463722102200222710ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.04/int64.mli000066400000000000000000000036271463722102200223040ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.04/lazy.mli000066400000000000000000000010141463722102200223030ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] ocaml-stdcompat-20~git20240529/interfaces/4.04/lexing.mli000066400000000000000000000027571463722102200226310ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (bytes -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.04/list.mli000066400000000000000000000041771463722102200223140ustar00rootroot00000000000000val length : 'a list -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.04/listLabels.mli000066400000000000000000000042771463722102200234400ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.04/map.mli000066400000000000000000000050461463722102200221120ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.04/marshal.mli000066400000000000000000000011041463722102200227530ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_string" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.04/moreLabels.mli000066400000000000000000000220561463722102200234220ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val max_binding : 'a t -> (key * 'a) val choose : 'a t -> (key * 'a) val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.04/nativeint.mli000066400000000000000000000035201463722102200233310ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.04/obj.mli000066400000000000000000000042521463722102200221050ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int[@@ocaml.deprecated "Replaced by custom_tag."] val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes[@@ocaml.deprecated "Use Marshal.to_bytes instead."] val unmarshal : bytes -> int -> (t * int)[@@ocaml.deprecated "Use Marshal.from_bytes and Marshal.total_size instead."] module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.04/oo.mli000066400000000000000000000002571463722102200217510ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.04/parsing.mli000066400000000000000000000017421463722102200227770ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/pervasives.mli000066400000000000000000000235561463722102200235320ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/printexc.mli000066400000000000000000000024641463722102200231720ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.04/printf.mli000066400000000000000000000013221463722102200226300ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.04/queue.mli000066400000000000000000000006501463722102200224550ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/random.mli000066400000000000000000000012701463722102200226100ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/scanf.mli000066400000000000000000000035541463722102200224310ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.bscanf."] val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.kscanf."] ocaml-stdcompat-20~git20240529/interfaces/4.04/set.mli000066400000000000000000000037341463722102200221320ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val max_elt : t -> elt val choose : t -> elt val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val of_list : elt list -> t end ocaml-stdcompat-20~git20240529/interfaces/4.04/sort.mli000066400000000000000000000007321463722102200223210ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list[@@ocaml.deprecated "Use List.sort instead."] val array : ('a -> 'a -> bool) -> 'a array -> unit[@@ocaml.deprecated "Use Array.sort instead."] val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list[@@ocaml.deprecated "Use List.merge instead."] ocaml-stdcompat-20~git20240529/interfaces/4.04/spacetime.mli000066400000000000000000000004721463722102200233050ustar00rootroot00000000000000module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/stack.mli000066400000000000000000000004731463722102200224410ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b ocaml-stdcompat-20~git20240529/interfaces/4.04/stdLabels.mli000066400000000000000000000176511463722102200232570ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module Bytes : sig external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val rindex : bytes -> char -> int val index_from : bytes -> int -> char -> int val rindex_from : bytes -> int -> char -> int val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes type t = bytes val compare : t -> t -> int external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assq : 'a -> ('a * 'b) list -> 'b val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] end ocaml-stdcompat-20~git20240529/interfaces/4.04/stream.mli000066400000000000000000000013201463722102200226170ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/string.mli000066400000000000000000000054501463722102200226420ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.04/stringLabels.mli000066400000000000000000000042751463722102200237710ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val rindex : string -> char -> int val index_from : string -> int -> char -> int val rindex_from : string -> int -> char -> int val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string type t = string val compare : t -> t -> int external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.04/sys.mli000066400000000000000000000040541463722102200221510ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.04/uchar.mli000066400000000000000000000006021463722102200224300ustar00rootroot00000000000000type t val min : t val max : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int val dump : Format.formatter -> t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.04/weak.mli000066400000000000000000000024651463722102200222660ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.05/000077500000000000000000000000001463722102200206265ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.05/arg.mli000066400000000000000000000030341463722102200221020ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/array.mli000066400000000000000000000040441463722102200224510ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.05/arrayLabels.mli000066400000000000000000000042501463722102200235730ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" ocaml-stdcompat-20~git20240529/interfaces/4.05/buffer.mli000066400000000000000000000012661463722102200226070ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/bytes.mli000066400000000000000000000051131463722102200224570ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.05/bytesLabels.mli000066400000000000000000000053301463722102200236030ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.05/callback.mli000066400000000000000000000001231463722102200230610ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/char.mli000066400000000000000000000007761463722102200222600ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.05/complex.mli000066400000000000000000000006021463722102200227760ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.05/digest.mli000066400000000000000000000006221463722102200226100ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.05/ephemeron.mli000066400000000000000000000245611463722102200233230ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.05/filename.mli000066400000000000000000000015451463722102200231160ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.05/format.mli000066400000000000000000000204441463722102200226250ustar00rootroot00000000000000val open_box : int -> unit val close_box : unit -> unit val print_string : string -> unit val print_as : int -> string -> unit val print_int : int -> unit val print_float : float -> unit val print_char : char -> unit val print_bool : bool -> unit val print_space : unit -> unit val print_cut : unit -> unit val print_break : int -> int -> unit val print_flush : unit -> unit val print_newline : unit -> unit val force_newline : unit -> unit val print_if_newline : unit -> unit val set_margin : int -> unit val get_margin : unit -> int val set_max_indent : int -> unit val get_max_indent : unit -> int val set_max_boxes : int -> unit val get_max_boxes : unit -> int val over_max_boxes : unit -> bool val open_hbox : unit -> unit val open_vbox : int -> unit val open_hvbox : int -> unit val open_hovbox : int -> unit val set_ellipsis_text : string -> unit val get_ellipsis_text : unit -> string type tag = string val open_tag : tag -> unit val close_tag : unit -> unit val set_tags : bool -> unit val set_print_tags : bool -> unit val set_mark_tags : bool -> unit val get_print_tags : unit -> bool val get_mark_tags : unit -> bool val set_formatter_out_channel : out_channel -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit } val set_formatter_out_functions : formatter_out_functions -> unit val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val set_formatter_tag_functions : formatter_tag_functions -> unit val get_formatter_tag_functions : unit -> formatter_tag_functions type formatter val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val pp_open_hbox : formatter -> unit -> unit val pp_open_vbox : formatter -> int -> unit val pp_open_hvbox : formatter -> int -> unit val pp_open_hovbox : formatter -> int -> unit val pp_open_box : formatter -> int -> unit val pp_close_box : formatter -> unit -> unit val pp_open_tag : formatter -> string -> unit val pp_close_tag : formatter -> unit -> unit val pp_print_string : formatter -> string -> unit val pp_print_as : formatter -> int -> string -> unit val pp_print_int : formatter -> int -> unit val pp_print_float : formatter -> float -> unit val pp_print_char : formatter -> char -> unit val pp_print_bool : formatter -> bool -> unit val pp_print_break : formatter -> int -> int -> unit val pp_print_cut : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val pp_force_newline : formatter -> unit -> unit val pp_print_flush : formatter -> unit -> unit val pp_print_newline : formatter -> unit -> unit val pp_print_if_newline : formatter -> unit -> unit val pp_set_tags : formatter -> bool -> unit val pp_set_print_tags : formatter -> bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val pp_get_print_tags : formatter -> unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val pp_set_margin : formatter -> int -> unit val pp_get_margin : formatter -> unit -> int val pp_set_max_indent : formatter -> int -> unit val pp_get_max_indent : formatter -> unit -> int val pp_set_max_boxes : formatter -> int -> unit val pp_get_max_boxes : formatter -> unit -> int val pp_over_max_boxes : formatter -> unit -> bool val pp_set_ellipsis_text : formatter -> string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val pp_set_formatter_out_channel : formatter -> out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val pp_flush_formatter : formatter -> unit val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.set_formatter_out_functions instead."] val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.get_formatter_out_functions instead."] val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.pp_set_formatter_out_functions instead."] val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.pp_get_formatter_out_functions instead."] val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] ocaml-stdcompat-20~git20240529/interfaces/4.05/gc.mli000066400000000000000000000034721463722102200217300ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/genlex.mli000066400000000000000000000003011463722102200226050ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.05/hashtbl.mli000066400000000000000000000077741463722102200227750ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.05/int32.mli000066400000000000000000000033161463722102200222730ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.05/int64.mli000066400000000000000000000037021463722102200222770ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.05/lazy.mli000066400000000000000000000010141463722102200223040ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] ocaml-stdcompat-20~git20240529/interfaces/4.05/lexing.mli000066400000000000000000000027571463722102200226320ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (bytes -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.05/list.mli000066400000000000000000000046401463722102200223100ustar00rootroot00000000000000val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.05/listLabels.mli000066400000000000000000000050121463722102200234250ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.05/map.mli000066400000000000000000000066341463722102200221170ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> '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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.05/marshal.mli000066400000000000000000000011041463722102200227540ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_string" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.05/moreLabels.mli000066400000000000000000000257441463722102200234320ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.05/nativeint.mli000066400000000000000000000035771463722102200233460ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.05/obj.mli000066400000000000000000000042521463722102200221060ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int[@@ocaml.deprecated "Replaced by custom_tag."] val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes[@@ocaml.deprecated "Use Marshal.to_bytes instead."] val unmarshal : bytes -> int -> (t * int)[@@ocaml.deprecated "Use Marshal.from_bytes and Marshal.total_size instead."] module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.05/oo.mli000066400000000000000000000002571463722102200217520ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.05/parsing.mli000066400000000000000000000017421463722102200230000ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/pervasives.mli000066400000000000000000000241131463722102200235210ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/printexc.mli000066400000000000000000000026131463722102200231670ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.05/printf.mli000066400000000000000000000013221463722102200226310ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.05/queue.mli000066400000000000000000000006501463722102200224560ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/random.mli000066400000000000000000000012701463722102200226110ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/scanf.mli000066400000000000000000000035541463722102200224320ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.bscanf."] val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.kscanf."] ocaml-stdcompat-20~git20240529/interfaces/4.05/set.mli000066400000000000000000000052621463722102200221310ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t end ocaml-stdcompat-20~git20240529/interfaces/4.05/sort.mli000066400000000000000000000007321463722102200223220ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list[@@ocaml.deprecated "Use List.sort instead."] val array : ('a -> 'a -> bool) -> 'a array -> unit[@@ocaml.deprecated "Use Array.sort instead."] val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list[@@ocaml.deprecated "Use List.merge instead."] ocaml-stdcompat-20~git20240529/interfaces/4.05/spacetime.mli000066400000000000000000000005151463722102200233040ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/stack.mli000066400000000000000000000004731463722102200224420ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b ocaml-stdcompat-20~git20240529/interfaces/4.05/stdLabels.mli000066400000000000000000000226471463722102200232610ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" end module Bytes : sig external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] end ocaml-stdcompat-20~git20240529/interfaces/4.05/stream.mli000066400000000000000000000013201463722102200226200ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.05/string.mli000066400000000000000000000057661463722102200226550ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.05/stringLabels.mli000066400000000000000000000057641463722102200237760ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.05/sys.mli000066400000000000000000000041251463722102200221510ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.05/uchar.mli000066400000000000000000000005311463722102200224320ustar00rootroot00000000000000type t val min : t val max : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.05/weak.mli000066400000000000000000000026151463722102200222640ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.06/000077500000000000000000000000001463722102200206275ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.06/arg.mli000066400000000000000000000030341463722102200221030ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/array.mli000066400000000000000000000047701463722102200224600ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.06/arrayLabels.mli000066400000000000000000000051741463722102200236020ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.06/buffer.mli000066400000000000000000000014751463722102200226120ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/bytes.mli000066400000000000000000000051131463722102200224600ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.06/bytesLabels.mli000066400000000000000000000053401463722102200236050ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.06/callback.mli000066400000000000000000000001231463722102200230620ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/char.mli000066400000000000000000000007761463722102200222610ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.06/complex.mli000066400000000000000000000006021463722102200227770ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.06/digest.mli000066400000000000000000000006221463722102200226110ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.06/ephemeron.mli000066400000000000000000000245611463722102200233240ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.06/filename.mli000066400000000000000000000015451463722102200231170ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.06/format.mli000066400000000000000000000176711463722102200226360ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type tag = string val pp_open_tag : formatter -> string -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.set_formatter_out_functions instead."] val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.get_formatter_out_functions instead."] val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.pp_set_formatter_out_functions instead."] val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.pp_get_formatter_out_functions instead."] ocaml-stdcompat-20~git20240529/interfaces/4.06/gc.mli000066400000000000000000000034721463722102200217310ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/genlex.mli000066400000000000000000000003011463722102200226060ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.06/hashtbl.mli000066400000000000000000000077741463722102200227760ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.06/int32.mli000066400000000000000000000033161463722102200222740ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.06/int64.mli000066400000000000000000000037021463722102200223000ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.06/lazy.mli000066400000000000000000000010141463722102200223050ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] ocaml-stdcompat-20~git20240529/interfaces/4.06/lexing.mli000066400000000000000000000027571463722102200226330ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (bytes -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.06/list.mli000066400000000000000000000047111463722102200223100ustar00rootroot00000000000000val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.06/listLabels.mli000066400000000000000000000050711463722102200234330ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.06/map.mli000066400000000000000000000070361463722102200221150ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t end ocaml-stdcompat-20~git20240529/interfaces/4.06/marshal.mli000066400000000000000000000011041463722102200227550ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_string" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.06/moreLabels.mli000066400000000000000000000261661463722102200234320ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.06/nativeint.mli000066400000000000000000000035771463722102200233470ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.06/obj.mli000066400000000000000000000042521463722102200221070ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int[@@ocaml.deprecated "Replaced by custom_tag."] val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes[@@ocaml.deprecated "Use Marshal.to_bytes instead."] val unmarshal : bytes -> int -> (t * int)[@@ocaml.deprecated "Use Marshal.from_bytes and Marshal.total_size instead."] module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.06/oo.mli000066400000000000000000000002571463722102200217530ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.06/parsing.mli000066400000000000000000000017421463722102200230010ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/pervasives.mli000066400000000000000000000241131463722102200235220ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/printexc.mli000066400000000000000000000026131463722102200231700ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.06/printf.mli000066400000000000000000000013221463722102200226320ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.06/queue.mli000066400000000000000000000006501463722102200224570ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/random.mli000066400000000000000000000012701463722102200226120ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/scanf.mli000066400000000000000000000035671463722102200224370ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Pervasives.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.bscanf."] val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.kscanf."] ocaml-stdcompat-20~git20240529/interfaces/4.06/set.mli000066400000000000000000000052621463722102200221320ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t end ocaml-stdcompat-20~git20240529/interfaces/4.06/sort.mli000066400000000000000000000007321463722102200223230ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list[@@ocaml.deprecated "Use List.sort instead."] val array : ('a -> 'a -> bool) -> 'a array -> unit[@@ocaml.deprecated "Use Array.sort instead."] val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list[@@ocaml.deprecated "Use List.merge instead."] ocaml-stdcompat-20~git20240529/interfaces/4.06/spacetime.mli000066400000000000000000000005151463722102200233050ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/stack.mli000066400000000000000000000004731463722102200224430ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b ocaml-stdcompat-20~git20240529/interfaces/4.06/stdLabels.mli000066400000000000000000000237241463722102200232570ustar00rootroot00000000000000module Array : sig external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end end module Bytes : sig external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes end module List : sig val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list end module String : sig external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] end ocaml-stdcompat-20~git20240529/interfaces/4.06/stream.mli000066400000000000000000000013201463722102200226210ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.06/string.mli000066400000000000000000000057661463722102200226560ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.06/stringLabels.mli000066400000000000000000000061041463722102200237640ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.06/sys.mli000066400000000000000000000041251463722102200221520ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.06/uchar.mli000066400000000000000000000005611463722102200224360ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.06/weak.mli000066400000000000000000000026151463722102200222650ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.07/000077500000000000000000000000001463722102200206305ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.07/arg.mli000066400000000000000000000030341463722102200221040ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/array.mli000066400000000000000000000051471463722102200224600ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.07/arrayLabels.mli000066400000000000000000000053531463722102200236020ustar00rootroot00000000000000external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.07/buffer.mli000066400000000000000000000017031463722102200226050ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t ocaml-stdcompat-20~git20240529/interfaces/4.07/bytes.mli000066400000000000000000000052531463722102200224660ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.07/bytesLabels.mli000066400000000000000000000055001463722102200236040ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.07/callback.mli000066400000000000000000000001231463722102200230630ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/char.mli000066400000000000000000000007761463722102200222620ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.07/complex.mli000066400000000000000000000006021463722102200230000ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.07/digest.mli000066400000000000000000000006221463722102200226120ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.07/ephemeron.mli000066400000000000000000000315441463722102200233240ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.07/filename.mli000066400000000000000000000015451463722102200231200ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.07/float.mli000066400000000000000000000075351463722102200224520ustar00rootroot00000000000000external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val hash : t -> int module Array : sig type t = floatarray external create : int -> t = "caml_floatarray_create" external length : t -> int = "%floatarray_length" external get : t -> int -> float = "%floatarray_safe_get" external set : t -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.07/format.mli000066400000000000000000000176711463722102200226370ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type tag = string val pp_open_tag : formatter -> string -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.set_formatter_out_functions instead."] val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.get_formatter_out_functions instead."] val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit[@@ocaml.deprecated "Use Format.pp_set_formatter_out_functions instead."] val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit))[@@ocaml.deprecated "Use Format.pp_get_formatter_out_functions instead."] ocaml-stdcompat-20~git20240529/interfaces/4.07/gc.mli000066400000000000000000000034721463722102200217320ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/genlex.mli000066400000000000000000000003011463722102200226070ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.07/hashtbl.mli000066400000000000000000000125161463722102200227650ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.07/int32.mli000066400000000000000000000033161463722102200222750ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" external rem : int32 -> int32 -> int32 = "%int32_mod" val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.07/int64.mli000066400000000000000000000037021463722102200223010ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" external rem : int64 -> int64 -> int64 = "%int64_mod" val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.07/lazy.mli000066400000000000000000000010141463722102200223060ustar00rootroot00000000000000type 'a t = 'a lazy_t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] ocaml-stdcompat-20~git20240529/interfaces/4.07/lexing.mli000066400000000000000000000027571463722102200226340ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : in_channel -> lexbuf val from_string : string -> lexbuf val from_function : (bytes -> int -> int) -> lexbuf val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.07/list.mli000066400000000000000000000050131463722102200223050ustar00rootroot00000000000000val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.07/listLabels.mli000066400000000000000000000051731463722102200234370ustar00rootroot00000000000000val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.07/map.mli000066400000000000000000000076301463722102200221160ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.07/marshal.mli000066400000000000000000000011031463722102200227550ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.07/moreLabels.mli000066400000000000000000000324341463722102200234260ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.07/nativeint.mli000066400000000000000000000035771463722102200233500ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.07/obj.mli000066400000000000000000000042521463722102200221100ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int[@@ocaml.deprecated "Replaced by custom_tag."] val int_tag : int val out_of_heap_tag : int val unaligned_tag : int val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes[@@ocaml.deprecated "Use Marshal.to_bytes instead."] val unmarshal : bytes -> int -> (t * int)[@@ocaml.deprecated "Use Marshal.from_bytes and Marshal.total_size instead."] module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.07/oo.mli000066400000000000000000000002571463722102200217540ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.07/parsing.mli000066400000000000000000000017421463722102200230020ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/pervasives.mli000066400000000000000000000241131463722102200235230ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/printexc.mli000066400000000000000000000026131463722102200231710ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.07/printf.mli000066400000000000000000000013221463722102200226330ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.07/queue.mli000066400000000000000000000010131463722102200224520ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val pop : 'a t -> 'a val peek : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.07/random.mli000066400000000000000000000012701463722102200226130ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/scanf.mli000066400000000000000000000035671463722102200224400ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Pervasives.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.bscanf."] val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner[@@ocaml.deprecated "Use Scanning.from_channel then Scanf.kscanf."] ocaml-stdcompat-20~git20240529/interfaces/4.07/seq.mli000066400000000000000000000005761463722102200221330ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/set.mli000066400000000000000000000057261463722102200221400ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.07/sort.mli000066400000000000000000000007321463722102200223240ustar00rootroot00000000000000val list : ('a -> 'a -> bool) -> 'a list -> 'a list[@@ocaml.deprecated "Use List.sort instead."] val array : ('a -> 'a -> bool) -> 'a array -> unit[@@ocaml.deprecated "Use Array.sort instead."] val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list[@@ocaml.deprecated "Use List.merge instead."] ocaml-stdcompat-20~git20240529/interfaces/4.07/spacetime.mli000066400000000000000000000005151463722102200233060ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/stack.mli000066400000000000000000000006361463722102200224450ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.07/stdLabels.mli000066400000000000000000000001541463722102200232500ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.07/stream.mli000066400000000000000000000013201463722102200226220ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.07/string.mli000066400000000000000000000061261463722102200226460ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.07/stringLabels.mli000066400000000000000000000062441463722102200237720ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.07/sys.mli000066400000000000000000000041251463722102200221530ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.07/uchar.mli000066400000000000000000000005611463722102200224370ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.07/weak.mli000066400000000000000000000026151463722102200222660ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.08/000077500000000000000000000000001463722102200206315ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.08/arg.mli000066400000000000000000000030341463722102200221050ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/array.mli000066400000000000000000000045121463722102200224540ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.08/arrayLabels.mli000066400000000000000000000047041463722102200236020ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.08/bool.mli000066400000000000000000000004671463722102200222760ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.08/buffer.mli000066400000000000000000000027031463722102200226070ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/bytes.mli000066400000000000000000000070031463722102200224620ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.08/bytesLabels.mli000066400000000000000000000072301463722102200236070ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.08/callback.mli000066400000000000000000000001231463722102200230640ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/char.mli000066400000000000000000000005221463722102200222500ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.08/complex.mli000066400000000000000000000006021463722102200230010ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.08/digest.mli000066400000000000000000000006221463722102200226130ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.08/ephemeron.mli000066400000000000000000000315441463722102200233250ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.08/filename.mli000066400000000000000000000015131463722102200231140ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.08/float.mli000066400000000000000000000172271463722102200224520ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.08/format.mli000066400000000000000000000215401463722102200226260ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.08/fun.mli000066400000000000000000000003621463722102200221250ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.08/gc.mli000066400000000000000000000036211463722102200217270ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/genlex.mli000066400000000000000000000003011463722102200226100ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.08/hashtbl.mli000066400000000000000000000125161463722102200227660ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.08/int32.mli000066400000000000000000000035631463722102200223020ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.08/int64.mli000066400000000000000000000041471463722102200223060ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.08/lazy.mli000066400000000000000000000004751463722102200223210ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.08/lexing.mli000066400000000000000000000031331463722102200226220ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.08/list.mli000066400000000000000000000051741463722102200223160ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.08/listLabels.mli000066400000000000000000000053561463722102200234430ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.08/map.mli000066400000000000000000000076301463722102200221170ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.08/marshal.mli000066400000000000000000000011031463722102200227560ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.08/moreLabels.mli000066400000000000000000000325441463722102200234310ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.08/nativeint.mli000066400000000000000000000041001463722102200233300ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.08/obj.mli000066400000000000000000000041701463722102200221100ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes val unmarshal : bytes -> int -> (t * int) module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.08/oo.mli000066400000000000000000000002571463722102200217550ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.08/option.mli000066400000000000000000000013331463722102200226440ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.08/parsing.mli000066400000000000000000000017421463722102200230030ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/pervasives.mli000066400000000000000000000240071463722102200235260ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/printexc.mli000066400000000000000000000026351463722102200231760ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.08/printf.mli000066400000000000000000000013221463722102200226340ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.08/queue.mli000066400000000000000000000011151463722102200224560ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.08/random.mli000066400000000000000000000012701463722102200226140ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/result.mli000066400000000000000000000021341463722102200226520ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.08/scanf.mli000066400000000000000000000031641463722102200224320ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.08/seq.mli000066400000000000000000000005761463722102200221340ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/set.mli000066400000000000000000000060321463722102200221300ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.08/spacetime.mli000066400000000000000000000005151463722102200233070ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/stack.mli000066400000000000000000000007361463722102200224470ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.08/stdLabels.mli000066400000000000000000000001541463722102200232510ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.08/stdlib.mli000066400000000000000000000267641463722102200226340ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Spacetime = Spacetime module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.08/stream.mli000066400000000000000000000013201463722102200226230ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.08/string.mli000066400000000000000000000042271463722102200226470ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.08/stringLabels.mli000066400000000000000000000043771463722102200240000ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.08/sys.mli000066400000000000000000000041651463722102200221600ustar00rootroot00000000000000val argv : string array val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.08/uchar.mli000066400000000000000000000005611463722102200224400ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.08/unit.mli000066400000000000000000000001531463722102200223120ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.08/weak.mli000066400000000000000000000026151463722102200222670ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.09/000077500000000000000000000000001463722102200206325ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.09/arg.mli000066400000000000000000000030341463722102200221060ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/array.mli000066400000000000000000000045121463722102200224550ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.09/arrayLabels.mli000066400000000000000000000047041463722102200236030ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.09/bool.mli000066400000000000000000000004671463722102200222770ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.09/buffer.mli000066400000000000000000000027031463722102200226100ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/bytes.mli000066400000000000000000000072651463722102200224750ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.09/bytesLabels.mli000066400000000000000000000074461463722102200236210ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.09/callback.mli000066400000000000000000000001231463722102200230650ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/char.mli000066400000000000000000000005221463722102200222510ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.09/complex.mli000066400000000000000000000006021463722102200230020ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.09/digest.mli000066400000000000000000000006221463722102200226140ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.09/ephemeron.mli000066400000000000000000000315441463722102200233260ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.09/filename.mli000066400000000000000000000015131463722102200231150ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string ocaml-stdcompat-20~git20240529/interfaces/4.09/float.mli000066400000000000000000000172271463722102200224530ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.09/format.mli000066400000000000000000000215401463722102200226270ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.09/fun.mli000066400000000000000000000003621463722102200221260ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.09/gc.mli000066400000000000000000000036211463722102200217300ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/genlex.mli000066400000000000000000000003011463722102200226110ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.09/hashtbl.mli000066400000000000000000000125161463722102200227670ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.09/int32.mli000066400000000000000000000035631463722102200223030ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.09/int64.mli000066400000000000000000000041471463722102200223070ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.09/lazy.mli000066400000000000000000000004751463722102200223220ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.09/lexing.mli000066400000000000000000000031331463722102200226230ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.09/list.mli000066400000000000000000000051741463722102200223170ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.09/listLabels.mli000066400000000000000000000053561463722102200234440ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.09/map.mli000066400000000000000000000076301463722102200221200ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.09/marshal.mli000066400000000000000000000011031463722102200227570ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.09/moreLabels.mli000066400000000000000000000325441463722102200234320ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.09/nativeint.mli000066400000000000000000000041001463722102200233310ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.09/obj.mli000066400000000000000000000042601463722102200221110ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes val unmarshal : bytes -> int -> (t * int) module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.09/oo.mli000066400000000000000000000002571463722102200217560ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.09/option.mli000066400000000000000000000013331463722102200226450ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.09/parsing.mli000066400000000000000000000017421463722102200230040ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/pervasives.mli000066400000000000000000000240071463722102200235270ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/printexc.mli000066400000000000000000000027531463722102200232000ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" val get_callstack : int -> raw_backtrace val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.09/printf.mli000066400000000000000000000013221463722102200226350ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.09/queue.mli000066400000000000000000000011151463722102200224570ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.09/random.mli000066400000000000000000000012701463722102200226150ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/result.mli000066400000000000000000000021341463722102200226530ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.09/scanf.mli000066400000000000000000000031641463722102200224330ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.09/seq.mli000066400000000000000000000005761463722102200221350ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/set.mli000066400000000000000000000060321463722102200221310ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.09/spacetime.mli000066400000000000000000000005151463722102200233100ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/stack.mli000066400000000000000000000007361463722102200224500ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.09/stdLabels.mli000066400000000000000000000001541463722102200232520ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.09/stdlib.mli000066400000000000000000000270071463722102200226240ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Spacetime = Spacetime module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.09/stream.mli000066400000000000000000000013201463722102200226240ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.09/string.mli000066400000000000000000000042271463722102200226500ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.09/stringLabels.mli000066400000000000000000000043771463722102200240010ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.09/sys.mli000066400000000000000000000042101463722102200221500ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" ocaml-stdcompat-20~git20240529/interfaces/4.09/uchar.mli000066400000000000000000000005611463722102200224410ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.09/unit.mli000066400000000000000000000001531463722102200223130ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.09/weak.mli000066400000000000000000000026151463722102200222700ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.10/000077500000000000000000000000001463722102200206225ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.10/arg.mli000066400000000000000000000030341463722102200220760ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/array.mli000066400000000000000000000045121463722102200224450ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.10/arrayLabels.mli000066400000000000000000000047041463722102200235730ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.10/bool.mli000066400000000000000000000004671463722102200222670ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.10/buffer.mli000066400000000000000000000027031463722102200226000ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/bytes.mli000066400000000000000000000072651463722102200224650ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.10/bytesLabels.mli000066400000000000000000000074461463722102200236110ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.10/callback.mli000066400000000000000000000001231463722102200230550ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/char.mli000066400000000000000000000005221463722102200222410ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.10/complex.mli000066400000000000000000000006021463722102200227720ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.10/digest.mli000066400000000000000000000006221463722102200226040ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.10/ephemeron.mli000066400000000000000000000315441463722102200233160ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.10/filename.mli000066400000000000000000000017221463722102200231070ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/4.10/float.mli000066400000000000000000000172271463722102200224430ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.10/format.mli000066400000000000000000000215401463722102200226170ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.10/fun.mli000066400000000000000000000003621463722102200221160ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.10/gc.mli000066400000000000000000000036211463722102200217200ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/genlex.mli000066400000000000000000000003011463722102200226010ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.10/hashtbl.mli000066400000000000000000000125161463722102200227570ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.10/int32.mli000066400000000000000000000035631463722102200222730ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.10/int64.mli000066400000000000000000000041471463722102200222770ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.10/lazy.mli000066400000000000000000000004751463722102200223120ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.10/lexing.mli000066400000000000000000000031331463722102200226130ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.10/list.mli000066400000000000000000000053541463722102200223070ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_map : ('a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.10/listLabels.mli000066400000000000000000000055421463722102200234310ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.10/map.mli000066400000000000000000000076301463722102200221100ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.10/marshal.mli000066400000000000000000000011031463722102200227470ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.10/moreLabels.mli000066400000000000000000000325441463722102200234220ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.10/nativeint.mli000066400000000000000000000041001463722102200233210ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.10/obj.mli000066400000000000000000000042601463722102200221010ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes val unmarshal : bytes -> int -> (t * int) module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.10/oo.mli000066400000000000000000000002571463722102200217460ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.10/option.mli000066400000000000000000000013331463722102200226350ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.10/parsing.mli000066400000000000000000000017421463722102200227740ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/pervasives.mli000066400000000000000000000240071463722102200235170ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/printexc.mli000066400000000000000000000030171463722102200231620ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.10/printf.mli000066400000000000000000000013221463722102200226250ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.10/queue.mli000066400000000000000000000011151463722102200224470ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.10/random.mli000066400000000000000000000012701463722102200226050ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/result.mli000066400000000000000000000021341463722102200226430ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.10/scanf.mli000066400000000000000000000031641463722102200224230ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.10/seq.mli000066400000000000000000000005761463722102200221250ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/set.mli000066400000000000000000000060321463722102200221210ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.10/spacetime.mli000066400000000000000000000005151463722102200233000ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/stack.mli000066400000000000000000000007361463722102200224400ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.10/stdLabels.mli000066400000000000000000000001541463722102200232420ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.10/stdlib.mli000066400000000000000000000270071463722102200226140ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Spacetime = Spacetime module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.10/stream.mli000066400000000000000000000013201463722102200226140ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.10/string.mli000066400000000000000000000042271463722102200226400ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.10/stringLabels.mli000066400000000000000000000043771463722102200237710ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.10/sys.mli000066400000000000000000000050551463722102200221500ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/4.10/uchar.mli000066400000000000000000000005611463722102200224310ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.10/unit.mli000066400000000000000000000001531463722102200223030ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.10/weak.mli000066400000000000000000000026151463722102200222600ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.11/000077500000000000000000000000001463722102200206235ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.11/arg.mli000066400000000000000000000030341463722102200220770ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/array.mli000066400000000000000000000047151463722102200224530ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.11/arrayLabels.mli000066400000000000000000000051131463722102200235670ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val exists : f:('a -> bool) -> 'a array -> bool val for_all : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.11/bool.mli000066400000000000000000000004671463722102200222700ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.11/buffer.mli000066400000000000000000000027031463722102200226010ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/bytes.mli000066400000000000000000000072651463722102200224660ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.11/bytesLabels.mli000066400000000000000000000074461463722102200236120ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes ocaml-stdcompat-20~git20240529/interfaces/4.11/callback.mli000066400000000000000000000001231463722102200230560ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/char.mli000066400000000000000000000005221463722102200222420ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.11/complex.mli000066400000000000000000000006021463722102200227730ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.11/digest.mli000066400000000000000000000006221463722102200226050ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.11/ephemeron.mli000066400000000000000000000315441463722102200233170ustar00rootroot00000000000000module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.11/filename.mli000066400000000000000000000017221463722102200231100ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/4.11/float.mli000066400000000000000000000172271463722102200224440ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.11/format.mli000066400000000000000000000217321463722102200226230ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.11/fun.mli000066400000000000000000000003621463722102200221170ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.11/gc.mli000066400000000000000000000051261463722102200217230ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit external eventlog_pause : unit -> unit = "caml_eventlog_pause" external eventlog_resume : unit -> unit = "caml_eventlog_resume" module Memprof : sig type allocation = private { n_samples: int ; size: int ; unmarshalled: bool ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> unit val stop : unit -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.11/genlex.mli000066400000000000000000000003011463722102200226020ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.11/hashtbl.mli000066400000000000000000000125161463722102200227600ustar00rootroot00000000000000type ('a, 'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.11/int32.mli000066400000000000000000000035631463722102200222740ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.11/int64.mli000066400000000000000000000041471463722102200223000ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.11/lazy.mli000066400000000000000000000004751463722102200223130ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.11/lexing.mli000066400000000000000000000032651463722102200226220ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.11/list.mli000066400000000000000000000055651463722102200223140ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_map : ('a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.11/listLabels.mli000066400000000000000000000057641463722102200234400ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val hd : 'a list -> 'a val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.11/map.mli000066400000000000000000000100241463722102200221000ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.11/marshal.mli000066400000000000000000000011031463722102200227500ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.11/moreLabels.mli000066400000000000000000000331261463722102200234200ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool type statistics = Hashtbl.statistics val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = Hashtbl.HashedType module type SeededHashedType = Hashtbl.SeededHashedType module type S = sig type key and 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededS = sig type key and 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t and 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = Map.OrderedType module type S = sig type key and +'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t and 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = Set.OrderedType module type S = sig type elt and t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t and t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.11/nativeint.mli000066400000000000000000000041001463722102200233220ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.11/obj.mli000066400000000000000000000042601463722102200221020ustar00rootroot00000000000000type t external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag" external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes val unmarshal : bytes -> int -> (t * int) module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.11/oo.mli000066400000000000000000000002571463722102200217470ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.11/option.mli000066400000000000000000000013331463722102200226360ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.11/parsing.mli000066400000000000000000000017421463722102200227750ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/pervasives.mli000066400000000000000000000240071463722102200235200ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/printexc.mli000066400000000000000000000031651463722102200231670ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.11/printf.mli000066400000000000000000000015501463722102200226310ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.11/queue.mli000066400000000000000000000011151463722102200224500ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.11/random.mli000066400000000000000000000012701463722102200226060ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/result.mli000066400000000000000000000021341463722102200226440ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.11/scanf.mli000066400000000000000000000031641463722102200224240ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.11/seq.mli000066400000000000000000000007621463722102200221230ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val append : 'a t -> 'a t -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.11/set.mli000066400000000000000000000062001463722102200221170ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.11/spacetime.mli000066400000000000000000000005151463722102200233010ustar00rootroot00000000000000val enabled : bool module Series : sig type t val create : path:string -> t val save_event : ?time:float -> t -> event_name:string -> unit val save_and_close : ?time:float -> t -> unit end module Snapshot : sig val take : ?time:float -> Series.t -> unit end val save_event_for_automatic_snapshots : event_name:string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/stack.mli000066400000000000000000000007361463722102200224410ustar00rootroot00000000000000type 'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.11/stdLabels.mli000066400000000000000000000001541463722102200232430ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.11/stdlib.mli000066400000000000000000000270071463722102200226150ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Spacetime = Spacetime module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.11/stream.mli000066400000000000000000000013201463722102200226150ustar00rootroot00000000000000type 'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.11/string.mli000066400000000000000000000042271463722102200226410ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> (int -> char) -> string val copy : string -> string val sub : string -> int -> int -> string val fill : bytes -> int -> int -> char -> unit val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.11/stringLabels.mli000066400000000000000000000043771463722102200237720ustar00rootroot00000000000000external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" external set : bytes -> int -> char -> unit = "%string_safe_set" external create : int -> bytes = "caml_create_string" val make : int -> char -> string val init : int -> f:(int -> char) -> string val copy : string -> string val sub : string -> pos:int -> len:int -> string val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val contains : string -> char -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string type t = string val compare : t -> t -> int val equal : t -> t -> bool val split_on_char : sep:char -> string -> string list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.11/sys.mli000066400000000000000000000050551463722102200221510ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/4.11/uchar.mli000066400000000000000000000005611463722102200224320ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.11/unit.mli000066400000000000000000000001531463722102200223040ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.11/weak.mli000066400000000000000000000026151463722102200222610ustar00rootroot00000000000000type 'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.12/000077500000000000000000000000001463722102200206245ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.12/arg.mli000066400000000000000000000031031463722102200220750ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/array.mli000066400000000000000000000047151463722102200224540ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.12/arrayLabels.mli000066400000000000000000000051131463722102200235700ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : f:('a -> bool) -> 'a array -> bool val exists : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.12/atomic.mli000066400000000000000000000003741463722102200226070ustar00rootroot00000000000000type !'a t val make : 'a -> 'a t val get : 'a t -> 'a val set : 'a t -> 'a -> unit val exchange : 'a t -> 'a -> 'a val compare_and_set : 'a t -> 'a -> 'a -> bool val fetch_and_add : int t -> int -> int val incr : int t -> unit val decr : int t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/bool.mli000066400000000000000000000004671463722102200222710ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.12/buffer.mli000066400000000000000000000027031463722102200226020ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/bytes.mli000066400000000000000000000072651463722102200224670ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.12/bytesLabels.mli000066400000000000000000000074461463722102200236130ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.12/callback.mli000066400000000000000000000001231463722102200230570ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/char.mli000066400000000000000000000005221463722102200222430ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.12/complex.mli000066400000000000000000000006021463722102200227740ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.12/digest.mli000066400000000000000000000006221463722102200226060ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.12/either.mli000066400000000000000000000015641463722102200226150ustar00rootroot00000000000000type ('a, 'b) t = | Left of 'a | Right of 'b val left : 'a -> ('a, 'b) t val right : 'b -> ('a, 'b) t val is_left : ('a, 'b) t -> bool val is_right : ('a, 'b) t -> bool val find_left : ('a, 'b) t -> 'a option val find_right : ('a, 'b) t -> 'b option val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int ocaml-stdcompat-20~git20240529/interfaces/4.12/ephemeron.mli000066400000000000000000000315551463722102200233220ustar00rootroot00000000000000module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.12/filename.mli000066400000000000000000000017221463722102200231110ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/4.12/float.mli000066400000000000000000000172271463722102200224450ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.12/format.mli000066400000000000000000000221251463722102200226210ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.12/fun.mli000066400000000000000000000003621463722102200221200ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.12/gc.mli000066400000000000000000000053051463722102200217230ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int ; forced_major_collections: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit external eventlog_pause : unit -> unit = "caml_eventlog_pause" external eventlog_resume : unit -> unit = "caml_eventlog_resume" module Memprof : sig type allocation_source = | Normal | Marshal | Custom type allocation = private { n_samples: int ; size: int ; source: allocation_source ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> unit val stop : unit -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.12/genlex.mli000066400000000000000000000003011463722102200226030ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.12/hashtbl.mli000066400000000000000000000126131463722102200227570ustar00rootroot00000000000000type (!'a, !'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.12/int32.mli000066400000000000000000000035631463722102200222750ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.12/int64.mli000066400000000000000000000041471463722102200223010ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.12/lazy.mli000066400000000000000000000004751463722102200223140ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val force_val : 'a t -> 'a val from_fun : (unit -> 'a) -> 'a t val from_val : 'a -> 'a t val is_val : 'a t -> bool val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.12/lexing.mli000066400000000000000000000032651463722102200226230ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.12/list.mli000066400000000000000000000061011463722102200223000ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_map : ('a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.12/listLabels.mli000066400000000000000000000063111463722102200234260ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.12/map.mli000066400000000000000000000101621463722102200221040ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.12/marshal.mli000066400000000000000000000011031463722102200227510ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.12/moreLabels.mli000066400000000000000000000341211463722102200234150ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.12/nativeint.mli000066400000000000000000000041001463722102200233230ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.12/obj.mli000066400000000000000000000047201463722102200221040ustar00rootroot00000000000000type t type raw_data = nativeint external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag"[@@noalloc ] external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external raw_field : t -> int -> raw_data = "caml_obj_raw_field" external set_raw_field : t -> int -> raw_data -> unit = "caml_obj_set_raw_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Closure : sig type info = { arity: int ; start_env: int } val info : t -> info end module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes val unmarshal : bytes -> int -> (t * int) module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.12/oo.mli000066400000000000000000000002571463722102200217500ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.12/option.mli000066400000000000000000000013331463722102200226370ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.12/parsing.mli000066400000000000000000000017421463722102200227760ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/pervasives.mli000066400000000000000000000240071463722102200235210ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/printexc.mli000066400000000000000000000034731463722102200231720ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace type raw_backtrace_entry = private int val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.12/printf.mli000066400000000000000000000015501463722102200226320ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.12/queue.mli000066400000000000000000000011161463722102200224520ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.12/random.mli000066400000000000000000000012701463722102200226070ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/result.mli000066400000000000000000000021341463722102200226450ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.12/scanf.mli000066400000000000000000000031641463722102200224250ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.12/seq.mli000066400000000000000000000007621463722102200221240ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val append : 'a t -> 'a t -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.12/set.mli000066400000000000000000000063101463722102200221220ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.12/stack.mli000066400000000000000000000007371463722102200224430ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.12/stdLabels.mli000066400000000000000000000001541463722102200232440ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.12/stdlib.mli000066400000000000000000000271111463722102200226120ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __FUNCTION__ : string = "%loc_FUNCTION" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Atomic = Atomic module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Either = Either module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.12/stream.mli000066400000000000000000000013211463722102200226170ustar00rootroot00000000000000type !'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.12/string.mli000066400000000000000000000042271463722102200226420ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> (int -> char) -> string external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : string -> string list -> string val equal : t -> t -> bool val compare : t -> t -> int val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> int -> int -> string val split_on_char : char -> string -> string list val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external create : int -> bytes = "caml_create_string" external set : bytes -> int -> char -> unit = "%string_safe_set" val blit : string -> int -> bytes -> int -> int -> unit val copy : string -> string val fill : bytes -> int -> int -> char -> unit val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.12/stringLabels.mli000066400000000000000000000043771463722102200237730ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> f:(int -> char) -> string external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : sep:string -> string list -> string val equal : t -> t -> bool val compare : t -> t -> int val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> pos:int -> len:int -> string val split_on_char : sep:char -> string -> string list val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external create : int -> bytes = "caml_create_string" external set : bytes -> int -> char -> unit = "%string_safe_set" val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val copy : string -> string val fill : bytes -> pos:int -> len:int -> char -> unit val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.12/sys.mli000066400000000000000000000052321463722102200221470ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/4.12/uchar.mli000066400000000000000000000005611463722102200224330ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.12/unit.mli000066400000000000000000000001531463722102200223050ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.12/weak.mli000066400000000000000000000026161463722102200222630ustar00rootroot00000000000000type !'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.13/000077500000000000000000000000001463722102200206255ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.13/arg.mli000066400000000000000000000031031463722102200220760ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/array.mli000066400000000000000000000053721463722102200224550ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b array -> ('a * 'c array) val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val find_opt : ('a -> bool) -> 'a array -> 'a option val find_map : ('a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.13/arrayLabels.mli000066400000000000000000000056031463722102200235750ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b array -> ('a * 'c array) val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : f:('a -> bool) -> 'a array -> bool val exists : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool val find_opt : f:('a -> bool) -> 'a array -> 'a option val find_map : f:('a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.13/atomic.mli000066400000000000000000000003741463722102200226100ustar00rootroot00000000000000type !'a t val make : 'a -> 'a t val get : 'a t -> 'a val set : 'a t -> 'a -> unit val exchange : 'a t -> 'a -> 'a val compare_and_set : 'a t -> 'a -> 'a -> bool val fetch_and_add : int t -> int -> int val incr : int t -> unit val decr : int t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/bool.mli000066400000000000000000000004671463722102200222720ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.13/buffer.mli000066400000000000000000000027031463722102200226030ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/bytes.mli000066400000000000000000000100171463722102200224550ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val fold_left : ('a -> char -> 'a) -> 'a -> bytes -> 'a val fold_right : (char -> 'a -> 'a) -> bytes -> 'a -> 'a val for_all : (char -> bool) -> bytes -> bool val exists : (char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.13/bytesLabels.mli000066400000000000000000000102261463722102200236020ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val fold_left : f:('a -> char -> 'a) -> init:'a -> bytes -> 'a val fold_right : f:(char -> 'a -> 'a) -> bytes -> init:'a -> 'a val for_all : f:(char -> bool) -> bytes -> bool val exists : f:(char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : sep:char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.13/callback.mli000066400000000000000000000001231463722102200230600ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/char.mli000066400000000000000000000005221463722102200222440ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.13/complex.mli000066400000000000000000000006021463722102200227750ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.13/digest.mli000066400000000000000000000006221463722102200226070ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.13/either.mli000066400000000000000000000015641463722102200226160ustar00rootroot00000000000000type ('a, 'b) t = | Left of 'a | Right of 'b val left : 'a -> ('a, 'b) t val right : 'b -> ('a, 'b) t val is_left : ('a, 'b) t -> bool val is_right : ('a, 'b) t -> bool val find_left : ('a, 'b) t -> 'a option val find_right : ('a, 'b) t -> 'b option val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int ocaml-stdcompat-20~git20240529/interfaces/4.13/ephemeron.mli000066400000000000000000000315551463722102200233230ustar00rootroot00000000000000module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.13/filename.mli000066400000000000000000000017221463722102200231120ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/4.13/float.mli000066400000000000000000000205351463722102200224420ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.13/format.mli000066400000000000000000000224551463722102200226300ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_bytes : formatter -> bytes -> unit val print_bytes : bytes -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.13/fun.mli000066400000000000000000000003621463722102200221210ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.13/gc.mli000066400000000000000000000053051463722102200217240ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int ; forced_major_collections: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit external eventlog_pause : unit -> unit = "caml_eventlog_pause" external eventlog_resume : unit -> unit = "caml_eventlog_resume" module Memprof : sig type allocation_source = | Normal | Marshal | Custom type allocation = private { n_samples: int ; size: int ; source: allocation_source ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> unit val stop : unit -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.13/genlex.mli000066400000000000000000000003011463722102200226040ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.13/hashtbl.mli000066400000000000000000000126131463722102200227600ustar00rootroot00000000000000type (!'a, !'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.13/int32.mli000066400000000000000000000036371463722102200223000ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.13/int64.mli000066400000000000000000000042231463722102200222750ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.13/lazy.mli000066400000000000000000000006131463722102200223070ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val map : ('a -> 'b) -> 'a t -> 'b t val is_val : 'a t -> bool val from_val : 'a -> 'a t val map_val : ('a -> 'b) -> 'a t -> 'b t val from_fun : (unit -> 'a) -> 'a t val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.13/lexing.mli000066400000000000000000000032651463722102200226240ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.13/list.mli000066400000000000000000000061011463722102200223010ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_map : ('a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.13/listLabels.mli000066400000000000000000000063111463722102200234270ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.13/map.mli000066400000000000000000000101621463722102200221050ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.13/marshal.mli000066400000000000000000000011031463722102200227520ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.13/moreLabels.mli000066400000000000000000000341211463722102200234160ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.13/nativeint.mli000066400000000000000000000041541463722102200233350ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.13/obj.mli000066400000000000000000000047201463722102200221050ustar00rootroot00000000000000type t type raw_data = nativeint external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag"[@@noalloc ] external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external raw_field : t -> int -> raw_data = "caml_obj_raw_field" external set_raw_field : t -> int -> raw_data -> unit = "caml_obj_set_raw_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Closure : sig type info = { arity: int ; start_env: int } val info : t -> info end module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int val marshal : t -> bytes val unmarshal : bytes -> int -> (t * int) module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.13/oo.mli000066400000000000000000000002571463722102200217510ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.13/option.mli000066400000000000000000000013331463722102200226400ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.13/parsing.mli000066400000000000000000000017421463722102200227770ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/pervasives.mli000066400000000000000000000240071463722102200235220ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/printexc.mli000066400000000000000000000034731463722102200231730ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace type raw_backtrace_entry = private int val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.13/printf.mli000066400000000000000000000015501463722102200226330ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.13/queue.mli000066400000000000000000000011161463722102200224530ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.13/random.mli000066400000000000000000000013631463722102200226130ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val full_int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val full_int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/result.mli000066400000000000000000000021341463722102200226460ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.13/scanf.mli000066400000000000000000000031641463722102200224260ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.13/seq.mli000066400000000000000000000010741463722102200221220ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val append : 'a t -> 'a t -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val concat : 'a t t -> 'a t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val concat_map : ('a -> 'b t) -> 'a t -> 'b t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iter : ('a -> unit) -> 'a t -> unit val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.13/set.mli000066400000000000000000000063101463722102200221230ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.13/stack.mli000066400000000000000000000007371463722102200224440ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.13/stdLabels.mli000066400000000000000000000001541463722102200232450ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.13/stdlib.mli000066400000000000000000000275321463722102200226220ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __FUNCTION__ : string = "%loc_FUNCTION" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Atomic = Atomic module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Either = Either module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.13/stream.mli000066400000000000000000000013211463722102200226200ustar00rootroot00000000000000type !'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.13/string.mli000066400000000000000000000061671463722102200226500ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> (int -> char) -> string val empty : string val of_bytes : bytes -> string val to_bytes : string -> bytes external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> int -> int -> string val split_on_char : char -> string -> string list val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a val for_all : (char -> bool) -> string -> bool val exists : (char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external create : int -> bytes = "caml_create_string" external set : bytes -> int -> char -> unit = "%string_safe_set" val blit : string -> int -> bytes -> int -> int -> unit val copy : string -> string val fill : bytes -> int -> int -> char -> unit val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.13/stringLabels.mli000066400000000000000000000063611463722102200237670ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> f:(int -> char) -> string val empty : string val of_bytes : bytes -> string val to_bytes : string -> bytes external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : sep:string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> pos:int -> len:int -> string val split_on_char : sep:char -> string -> string list val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val fold_left : f:('a -> char -> 'a) -> init:'a -> string -> 'a val fold_right : f:(char -> 'a -> 'a) -> string -> init:'a -> 'a val for_all : f:(char -> bool) -> string -> bool val exists : f:(char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t external create : int -> bytes = "caml_create_string" external set : bytes -> int -> char -> unit = "%string_safe_set" val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val copy : string -> string val fill : bytes -> pos:int -> len:int -> char -> unit val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.13/sys.mli000066400000000000000000000052321463722102200221500ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/4.13/uchar.mli000066400000000000000000000005611463722102200224340ustar00rootroot00000000000000type t val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.13/unit.mli000066400000000000000000000001531463722102200223060ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.13/weak.mli000066400000000000000000000026161463722102200222640ustar00rootroot00000000000000type !'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/4.14/000077500000000000000000000000001463722102200206265ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/4.14/arg.mli000066400000000000000000000031031463722102200220770ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/array.mli000066400000000000000000000053721463722102200224560ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val create_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b array -> ('a * 'c array) val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val find_opt : ('a -> bool) -> 'a array -> 'a option val find_map : ('a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.14/arrayLabels.mli000066400000000000000000000056031463722102200235760ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val make_float : int -> float array val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b array -> ('a * 'c array) val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : f:('a -> bool) -> 'a array -> bool val exists : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool val find_opt : f:('a -> bool) -> 'a array -> 'a option val find_map : f:('a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.14/atomic.mli000066400000000000000000000003741463722102200226110ustar00rootroot00000000000000type !'a t val make : 'a -> 'a t val get : 'a t -> 'a val set : 'a t -> 'a -> unit val exchange : 'a t -> 'a -> 'a val compare_and_set : 'a t -> 'a -> 'a -> bool val fetch_and_add : int t -> int -> int val incr : int t -> unit val decr : int t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/bool.mli000066400000000000000000000004671463722102200222730ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/4.14/buffer.mli000066400000000000000000000027031463722102200226040ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/bytes.mli000066400000000000000000000106521463722102200224630ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val fold_left : ('a -> char -> 'a) -> 'a -> bytes -> 'a val fold_right : (char -> 'a -> 'a) -> bytes -> 'a -> 'a val for_all : (char -> bool) -> bytes -> bool val exists : (char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.14/bytesLabels.mli000066400000000000000000000110611463722102200236010ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val fold_left : f:('a -> char -> 'a) -> init:'a -> bytes -> 'a val fold_right : f:(char -> 'a -> 'a) -> bytes -> init:'a -> 'a val for_all : f:(char -> bool) -> bytes -> bool val exists : f:(char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase : bytes -> bytes val lowercase : bytes -> bytes val capitalize : bytes -> bytes val uncapitalize : bytes -> bytes val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : sep:char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.14/callback.mli000066400000000000000000000001231463722102200230610ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/char.mli000066400000000000000000000005221463722102200222450ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase : char -> char val uppercase : char -> char val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/4.14/complex.mli000066400000000000000000000006021463722102200227760ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/4.14/digest.mli000066400000000000000000000006221463722102200226100ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/4.14/either.mli000066400000000000000000000015641463722102200226170ustar00rootroot00000000000000type ('a, 'b) t = | Left of 'a | Right of 'b val left : 'a -> ('a, 'b) t val right : 'b -> ('a, 'b) t val is_left : ('a, 'b) t -> bool val is_right : ('a, 'b) t -> bool val find_left : ('a, 'b) t -> 'a option val find_right : ('a, 'b) t -> 'b option val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int ocaml-stdcompat-20~git20240529/interfaces/4.14/ephemeron.mli000066400000000000000000000340631463722102200233210ustar00rootroot00000000000000module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val create : unit -> ('k, 'd) t val get_key : ('k, 'd) t -> 'k option val get_key_copy : ('k, 'd) t -> 'k option val set_key : ('k, 'd) t -> 'k -> unit val unset_key : ('k, 'd) t -> unit val check_key : ('k, 'd) t -> bool val blit_key : ('k, 'a) t -> ('k, 'b) t -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('a, 'd) t -> ('b, 'd) t -> unit val make : 'k -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k -> 'd -> unit val remove : ('k, 'd) t -> 'k -> unit val find : ('k, 'd) t -> 'k -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end module K2 : sig type ('k1, 'k2, 'd) t val create : unit -> ('k1, 'k2, 'd) t val get_key1 : ('k1, 'k2, 'd) t -> 'k1 option val get_key1_copy : ('k1, 'k2, 'd) t -> 'k1 option val set_key1 : ('k1, 'k2, 'd) t -> 'k1 -> unit val unset_key1 : ('k1, 'k2, 'd) t -> unit val check_key1 : ('k1, 'k2, 'd) t -> bool val get_key2 : ('k1, 'k2, 'd) t -> 'k2 option val get_key2_copy : ('k1, 'k2, 'd) t -> 'k2 option val set_key2 : ('k1, 'k2, 'd) t -> 'k2 -> unit val unset_key2 : ('k1, 'k2, 'd) t -> unit val check_key2 : ('k1, 'k2, 'd) t -> bool val blit_key1 : ('k1, 'a, 'b) t -> ('k1, 'c, 'd) t -> unit val blit_key2 : ('a, 'k2, 'b) t -> ('c, 'k2, 'd) t -> unit val blit_key12 : ('k1, 'k2, 'a) t -> ('k1, 'k2, 'b) t -> unit val get_data : ('k1, 'k2, 'd) t -> 'd option val get_data_copy : ('k1, 'k2, 'd) t -> 'd option val set_data : ('k1, 'k2, 'd) t -> 'd -> unit val unset_data : ('k1, 'k2, 'd) t -> unit val check_data : ('k1, 'k2, 'd) t -> bool val blit_data : ('k1, 'k2, 'd) t -> ('k1, 'k2, 'd) t -> unit val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) t val query : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k1, 'k2, 'd) t val make : unit -> ('k1, 'k2, 'd) t val add : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd -> unit val remove : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> unit val find : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option val length : ('k1, 'k2, 'd) t -> int val clear : ('k1, 'k2, 'd) t -> unit end end module Kn : sig type ('k, 'd) t val create : int -> ('k, 'd) t val get_key : ('k, 'd) t -> int -> 'k option val get_key_copy : ('k, 'd) t -> int -> 'k option val set_key : ('k, 'd) t -> int -> 'k -> unit val unset_key : ('k, 'd) t -> int -> unit val check_key : ('k, 'd) t -> int -> bool val blit_key : ('k, 'a) t -> int -> ('k, 'b) t -> int -> int -> unit val get_data : ('k, 'd) t -> 'd option val get_data_copy : ('k, 'd) t -> 'd option val set_data : ('k, 'd) t -> 'd -> unit val unset_data : ('k, 'd) t -> unit val check_data : ('k, 'd) t -> bool val blit_data : ('k, 'd) t -> ('k, 'd) t -> unit val make : 'k array -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k array -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k array -> 'd -> unit val remove : ('k, 'd) t -> 'k array -> unit val find : ('k, 'd) t -> 'k array -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end module GenHashTable : sig type equal = | ETrue | EFalse | EDead module MakeSeeded : functor (H : sig type t type 'a container val hash : int -> t -> int val equal : 'a container -> t -> equal val create : t -> 'a -> 'a container val get_key : 'a container -> t option val get_data : 'a container -> 'a option val set_key_data : 'a container -> t -> 'a -> unit val check_key : 'a container -> bool end) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end end ocaml-stdcompat-20~git20240529/interfaces/4.14/filename.mli000066400000000000000000000017221463722102200231130ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val temp_dir_name : string val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/4.14/float.mli000066400000000000000000000205351463722102200224430ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/4.14/format.mli000066400000000000000000000224551463722102200226310ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_bytes : formatter -> bytes -> unit val print_bytes : bytes -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val std_formatter : formatter val err_formatter : formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val str_formatter : formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) val pp_open_tag : formatter -> tag -> unit val open_tag : tag -> unit val pp_close_tag : formatter -> unit -> unit val close_tag : unit -> unit type formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit val set_formatter_tag_functions : formatter_tag_functions -> unit val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions val get_formatter_tag_functions : unit -> formatter_tag_functions ocaml-stdcompat-20~git20240529/interfaces/4.14/fun.mli000066400000000000000000000003621463722102200221220ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/4.14/gc.mli000066400000000000000000000053051463722102200217250ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int ; forced_major_collections: int } type control = { mutable minor_heap_size: int ; mutable major_heap_increment: int ; mutable space_overhead: int ; mutable verbose: int ; mutable max_overhead: int ; mutable stack_limit: int ; mutable allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ] external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ] external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit external eventlog_pause : unit -> unit = "caml_eventlog_pause" external eventlog_resume : unit -> unit = "caml_eventlog_resume" module Memprof : sig type allocation_source = | Normal | Marshal | Custom type allocation = private { n_samples: int ; size: int ; source: allocation_source ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> unit val stop : unit -> unit end ocaml-stdcompat-20~git20240529/interfaces/4.14/genlex.mli000066400000000000000000000003011463722102200226050ustar00rootroot00000000000000type token = | Kwd of string | Ident of string | Int of int | Float of float | String of string | Char of char val make_lexer : string list -> char Stream.t -> token Stream.t ocaml-stdcompat-20~git20240529/interfaces/4.14/hashtbl.mli000066400000000000000000000126131463722102200227610ustar00rootroot00000000000000type (!'a, !'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/4.14/in_channel.mli000066400000000000000000000016461463722102200234360ustar00rootroot00000000000000type t = in_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdin : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val close : t -> unit val close_noerr : t -> unit val input_char : t -> char option val input_byte : t -> int option val input_line : t -> string option val input : t -> bytes -> int -> int -> int val really_input : t -> bytes -> int -> int -> unit option val really_input_string : t -> int -> string option val input_all : t -> string val set_binary_mode : t -> bool -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/int32.mli000066400000000000000000000036371463722102200223010ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t external format : string -> int32 -> string = "caml_int32_format" ocaml-stdcompat-20~git20240529/interfaces/4.14/int64.mli000066400000000000000000000042231463722102200222760ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t external format : string -> int64 -> string = "caml_int64_format" ocaml-stdcompat-20~git20240529/interfaces/4.14/lazy.mli000066400000000000000000000006131463722102200223100ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val map : ('a -> 'b) -> 'a t -> 'b t val is_val : 'a t -> bool val from_val : 'a -> 'a t val map_val : ('a -> 'b) -> 'a t -> 'b t val from_fun : (unit -> 'a) -> 'a t val force_val : 'a t -> 'a val lazy_from_fun : (unit -> 'a) -> 'a t val lazy_from_val : 'a -> 'a t val lazy_is_val : 'a t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.14/lexing.mli000066400000000000000000000032651463722102200226250ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/4.14/list.mli000066400000000000000000000061011463722102200223020ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_map : ('a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.14/listLabels.mli000066400000000000000000000063111463722102200234300ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/4.14/map.mli000066400000000000000000000101621463722102200221060ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/4.14/marshal.mli000066400000000000000000000011031463722102200227530ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/4.14/moreLabels.mli000066400000000000000000000341211463722102200234170ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/4.14/nativeint.mli000066400000000000000000000041541463722102200233360ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t external format : string -> nativeint -> string = "caml_nativeint_format" ocaml-stdcompat-20~git20240529/interfaces/4.14/obj.mli000066400000000000000000000046151463722102200221110ustar00rootroot00000000000000type t type raw_data = nativeint external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag"[@@noalloc ] external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external set_tag : t -> int -> unit = "caml_obj_set_tag" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external raw_field : t -> int -> raw_data = "caml_obj_raw_field" external set_raw_field : t -> int -> raw_data -> unit = "caml_obj_set_raw_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external truncate : t -> int -> unit = "caml_obj_truncate" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val final_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Closure : sig type info = { arity: int ; start_env: int } val info : t -> info end module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end val extension_constructor : 'a -> extension_constructor val extension_name : extension_constructor -> string val extension_id : extension_constructor -> int module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/4.14/oo.mli000066400000000000000000000002571463722102200217520ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/4.14/option.mli000066400000000000000000000013331463722102200226410ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.14/out_channel.mli000066400000000000000000000020111463722102200236220ustar00rootroot00000000000000type t = out_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdout : t val stderr : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val close : t -> unit val close_noerr : t -> unit val flush : t -> unit val flush_all : unit -> unit val output_char : t -> char -> unit val output_byte : t -> int -> unit val output_string : t -> string -> unit val output_bytes : t -> bytes -> unit val output : t -> bytes -> int -> int -> unit val output_substring : t -> string -> int -> int -> unit val set_binary_mode : t -> bool -> unit val set_buffered : t -> bool -> unit val is_buffered : t -> bool ocaml-stdcompat-20~git20240529/interfaces/4.14/parsing.mli000066400000000000000000000017421463722102200230000ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/pervasives.mli000066400000000000000000000240071463722102200235230ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type nonrec fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string : string -> bool val bool_of_string_opt : string -> bool option val string_of_int : int -> string external int_of_string : string -> int = "caml_int_of_string" val int_of_string_opt : string -> int option val string_of_float : float -> string external float_of_string : string -> float = "caml_float_of_string" val float_of_string_opt : string -> float option external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type nonrec in_channel = in_channel type nonrec out_channel = out_channel val stdin : Stdlib.in_channel val stdout : Stdlib.out_channel val stderr : Stdlib.out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int : unit -> int val read_int_opt : unit -> int option val read_float : unit -> float val read_float_opt : unit -> float option type nonrec open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> Stdlib.out_channel val open_out_bin : string -> Stdlib.out_channel val open_out_gen : Stdlib.open_flag list -> int -> string -> Stdlib.out_channel val flush : Stdlib.out_channel -> unit val flush_all : unit -> unit val output_char : Stdlib.out_channel -> char -> unit val output_string : Stdlib.out_channel -> string -> unit val output_bytes : Stdlib.out_channel -> bytes -> unit val output : Stdlib.out_channel -> bytes -> int -> int -> unit val output_substring : Stdlib.out_channel -> string -> int -> int -> unit val output_byte : Stdlib.out_channel -> int -> unit val output_binary_int : Stdlib.out_channel -> int -> unit val output_value : Stdlib.out_channel -> 'a -> unit val seek_out : Stdlib.out_channel -> int -> unit val pos_out : Stdlib.out_channel -> int val out_channel_length : Stdlib.out_channel -> int val close_out : Stdlib.out_channel -> unit val close_out_noerr : Stdlib.out_channel -> unit val set_binary_mode_out : Stdlib.out_channel -> bool -> unit val open_in : string -> Stdlib.in_channel val open_in_bin : string -> Stdlib.in_channel val open_in_gen : Stdlib.open_flag list -> int -> string -> Stdlib.in_channel val input_char : Stdlib.in_channel -> char val input_line : Stdlib.in_channel -> string val input : Stdlib.in_channel -> bytes -> int -> int -> int val really_input : Stdlib.in_channel -> bytes -> int -> int -> unit val really_input_string : Stdlib.in_channel -> int -> string val input_byte : Stdlib.in_channel -> int val input_binary_int : Stdlib.in_channel -> int val input_value : Stdlib.in_channel -> 'a val seek_in : Stdlib.in_channel -> int -> unit val pos_in : Stdlib.in_channel -> int val in_channel_length : Stdlib.in_channel -> int val close_in : Stdlib.in_channel -> unit val close_in_noerr : Stdlib.in_channel -> unit val set_binary_mode_in : Stdlib.in_channel -> bool -> unit module LargeFile = LargeFile type nonrec 'a ref = 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type nonrec ('a, 'b) result = ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val do_at_exit : unit -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/printexc.mli000066400000000000000000000034731463722102200231740ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace type raw_backtrace_entry = private int val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string ocaml-stdcompat-20~git20240529/interfaces/4.14/printf.mli000066400000000000000000000015501463722102200226340ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/4.14/queue.mli000066400000000000000000000011161463722102200224540ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.14/random.mli000066400000000000000000000016561463722102200226210ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val full_int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool val bits32 : unit -> Int32.t val bits64 : unit -> Int64.t val nativebits : unit -> Nativeint.t module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val full_int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool val bits32 : t -> Int32.t val bits64 : t -> Int64.t val nativebits : t -> Nativeint.t end val get_state : unit -> State.t val set_state : State.t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/result.mli000066400000000000000000000021341463722102200226470ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/4.14/scanf.mli000066400000000000000000000031641463722102200224270ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string val stdib : in_channel end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val sscanf : string -> ('a, 'b, 'c, 'd) scanner val scanf : ('a, 'b, 'c, 'd) scanner val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string val fscanf : in_channel -> ('a, 'b, 'c, 'd) scanner val kfscanf : in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner ocaml-stdcompat-20~git20240529/interfaces/4.14/seq.mli000066400000000000000000000046661463722102200221350ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val is_empty : 'a t -> bool val uncons : 'a t -> ('a * 'a t) option val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iteri : (int -> 'a -> unit) -> 'a t -> unit val fold_lefti : (int -> 'b -> 'a -> 'b) -> 'b -> 'a t -> 'b val for_all : ('a -> bool) -> 'a t -> bool val exists : ('a -> bool) -> 'a t -> bool val find : ('a -> bool) -> 'a t -> 'a option val find_map : ('a -> 'b option) -> 'a t -> 'b option val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val init : int -> (int -> 'a) -> 'a t val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t val repeat : 'a -> 'a t val forever : (unit -> 'a) -> 'a t val cycle : 'a t -> 'a t val iterate : ('a -> 'a) -> 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t val take : int -> 'a t -> 'a t val drop : int -> 'a t -> 'a t val take_while : ('a -> bool) -> 'a t -> 'a t val drop_while : ('a -> bool) -> 'a t -> 'a t val group : ('a -> 'a -> bool) -> 'a t -> 'a t t val memoize : 'a t -> 'a t exception Forced_twice val once : 'a t -> 'a t val transpose : 'a t t -> 'a t t val append : 'a t -> 'a t -> 'a t val concat : 'a t t -> 'a t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val concat_map : ('a -> 'b t) -> 'a t -> 'b t val zip : 'a t -> 'b t -> ('a * 'b) t val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val interleave : 'a t -> 'a t -> 'a t val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t val product : 'a t -> 'b t -> ('a * 'b) t val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val unzip : ('a * 'b) t -> ('a t * 'b t) val split : ('a * 'b) t -> ('a t * 'b t) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> ('b t * 'c t) val partition : ('a -> bool) -> 'a t -> ('a t * 'a t) val of_dispenser : (unit -> 'a option) -> 'a t val to_dispenser : 'a t -> unit -> 'a option val ints : int -> int t ocaml-stdcompat-20~git20240529/interfaces/4.14/set.mli000066400000000000000000000063101463722102200221240ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/4.14/stack.mli000066400000000000000000000007371463722102200224450ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/4.14/stdLabels.mli000066400000000000000000000001541463722102200232460ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/4.14/stdlib.mli000066400000000000000000000276321463722102200226240ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external (or) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __FUNCTION__ : string = "%loc_FUNCTION" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external (mod) : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external (land) : int -> int -> int = "%andint" external (lor) : int -> int -> int = "%orint" external (lxor) : int -> int -> int = "%xorint" val lnot : int -> int external (lsl) : int -> int -> int = "%lslint" external (lsr) : int -> int -> int = "%lsrint" external (asr) : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Atomic = Atomic module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Digest = Digest module Either = Either module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Genlex = Genlex module Hashtbl = Hashtbl module In_channel = In_channel module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Out_channel = Out_channel module Parsing = Parsing module Pervasives = Pervasives module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Seq = Seq module Set = Set module Stack = Stack module StdLabels = StdLabels module Stream = Stream module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/4.14/stream.mli000066400000000000000000000013211463722102200226210ustar00rootroot00000000000000type !'a t exception Failure exception Error of string val from : (int -> 'a option) -> 'a t val of_list : 'a list -> 'a t val of_string : string -> char t val of_bytes : bytes -> char t val of_channel : in_channel -> char t val iter : ('a -> unit) -> 'a t -> unit val next : 'a t -> 'a val empty : 'a t -> unit val peek : 'a t -> 'a option val junk : 'a t -> unit val count : 'a t -> int val npeek : int -> 'a t -> 'a list val iapp : 'a t -> 'a t -> 'a t val icons : 'a -> 'a t -> 'a t val ising : 'a -> 'a t val lapp : (unit -> 'a t) -> 'a t -> 'a t val lcons : (unit -> 'a) -> 'a t -> 'a t val lsing : (unit -> 'a) -> 'a t val sempty : 'a t val slazy : (unit -> 'a t) -> 'a t val dump : ('a -> unit) -> 'a t -> unit ocaml-stdcompat-20~git20240529/interfaces/4.14/string.mli000066400000000000000000000065711463722102200226500ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> (int -> char) -> string val empty : string val of_bytes : bytes -> string val to_bytes : string -> bytes external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> int -> int -> string val split_on_char : char -> string -> string list val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a val for_all : (char -> bool) -> string -> bool val exists : (char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool external create : int -> bytes = "caml_create_string" external set : bytes -> int -> char -> unit = "%string_safe_set" val blit : string -> int -> bytes -> int -> int -> unit val copy : string -> string val fill : bytes -> int -> int -> char -> unit val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.14/stringLabels.mli000066400000000000000000000067631463722102200237760ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> f:(int -> char) -> string val empty : string val of_bytes : bytes -> string val to_bytes : string -> bytes external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : sep:string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> pos:int -> len:int -> string val split_on_char : sep:char -> string -> string list val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val fold_left : f:('a -> char -> 'a) -> init:'a -> string -> 'a val fold_right : f:(char -> 'a -> 'a) -> string -> init:'a -> 'a val for_all : f:(char -> bool) -> string -> bool val exists : f:(char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool external create : int -> bytes = "caml_create_string" external set : bytes -> int -> char -> unit = "%string_safe_set" val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val copy : string -> string val fill : bytes -> pos:int -> len:int -> char -> unit val uppercase : string -> string val lowercase : string -> string val capitalize : string -> string val uncapitalize : string -> string val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/4.14/sys.mli000066400000000000000000000056401463722102200221540ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val development_version : bool type extra_prefix = | Plus | Tilde type extra_info = (extra_prefix * string) type ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } val ocaml_release : ocaml_release_info val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/4.14/uchar.mli000066400000000000000000000012611463722102200224330ustar00rootroot00000000000000type t[@@immediate ] val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int type utf_decode[@@immediate ] val utf_decode_is_valid : utf_decode -> bool val utf_decode_uchar : utf_decode -> t val utf_decode_length : utf_decode -> int val utf_decode : int -> t -> utf_decode val utf_decode_invalid : int -> utf_decode val utf_8_byte_length : t -> int val utf_16_byte_length : t -> int ocaml-stdcompat-20~git20240529/interfaces/4.14/unit.mli000066400000000000000000000001531463722102200223070ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/4.14/weak.mli000066400000000000000000000026161463722102200222650ustar00rootroot00000000000000type !'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/5.0/000077500000000000000000000000001463722102200205425ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/5.0/arg.mli000066400000000000000000000031031463722102200220130ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/5.0/array.mli000066400000000000000000000051441463722102200223670ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b array -> ('a * 'c array) val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val find_opt : ('a -> bool) -> 'a array -> 'a option val find_map : ('a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.0/arrayLabels.mli000066400000000000000000000053431463722102200235130ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b array -> ('a * 'c array) val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : f:('a -> bool) -> 'a array -> bool val exists : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool val find_opt : f:('a -> bool) -> 'a array -> 'a option val find_map : f:('a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.0/atomic.mli000066400000000000000000000003741463722102200225250ustar00rootroot00000000000000type !'a t val make : 'a -> 'a t val get : 'a t -> 'a val set : 'a t -> 'a -> unit val exchange : 'a t -> 'a -> 'a val compare_and_set : 'a t -> 'a -> 'a -> bool val fetch_and_add : int t -> int -> int val incr : int t -> unit val decr : int t -> unit ocaml-stdcompat-20~git20240529/interfaces/5.0/bool.mli000066400000000000000000000004671463722102200222070ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string ocaml-stdcompat-20~git20240529/interfaces/5.0/buffer.mli000066400000000000000000000027031463722102200225200ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/5.0/bytes.mli000066400000000000000000000105151463722102200223750ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val fold_left : ('a -> char -> 'a) -> 'a -> bytes -> 'a val fold_right : (char -> 'a -> 'a) -> bytes -> 'a -> 'a val for_all : (char -> bool) -> bytes -> bool val exists : (char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_escape : bytes -> bytes ocaml-stdcompat-20~git20240529/interfaces/5.0/bytesLabels.mli000066400000000000000000000107241463722102200235220ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val fold_left : f:('a -> char -> 'a) -> init:'a -> bytes -> 'a val fold_right : f:(char -> 'a -> 'a) -> bytes -> init:'a -> 'a val for_all : f:(char -> bool) -> bytes -> bool val exists : f:(char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : sep:char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_escape : bytes -> bytes ocaml-stdcompat-20~git20240529/interfaces/5.0/callback.mli000066400000000000000000000001231463722102200227750ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/5.0/char.mli000066400000000000000000000004301463722102200221570ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/5.0/complex.mli000066400000000000000000000006021463722102200227120ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/5.0/digest.mli000066400000000000000000000006221463722102200225240ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/5.0/domain.mli000066400000000000000000000007521463722102200225200ustar00rootroot00000000000000type !'a t val spawn : (unit -> 'a) -> 'a t val join : 'a t -> 'a type id = private int val get_id : 'a t -> id val self : unit -> id val before_first_spawn : (unit -> unit) -> unit val at_exit : (unit -> unit) -> unit val cpu_relax : unit -> unit val is_main_domain : unit -> bool val recommended_domain_count : unit -> int module DLS : sig type 'a key val new_key : ?split_from_parent:('a -> 'a) -> (unit -> 'a) -> 'a key val get : 'a key -> 'a val set : 'a key -> 'a -> unit end ocaml-stdcompat-20~git20240529/interfaces/5.0/either.mli000066400000000000000000000015641463722102200225330ustar00rootroot00000000000000type ('a, 'b) t = | Left of 'a | Right of 'b val left : 'a -> ('a, 'b) t val right : 'b -> ('a, 'b) t val is_left : ('a, 'b) t -> bool val is_right : ('a, 'b) t -> bool val find_left : ('a, 'b) t -> 'a option val find_right : ('a, 'b) t -> 'b option val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int ocaml-stdcompat-20~git20240529/interfaces/5.0/ephemeron.mli000066400000000000000000000177041463722102200232400ustar00rootroot00000000000000module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val make : 'k -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k -> 'd -> unit val remove : ('k, 'd) t -> 'k -> unit val find : ('k, 'd) t -> 'k -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end module K2 : sig type ('k1, 'k2, 'd) t val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) t val query : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k1, 'k2, 'd) t val make : unit -> ('k1, 'k2, 'd) t val add : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd -> unit val remove : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> unit val find : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option val length : ('k1, 'k2, 'd) t -> int val clear : ('k1, 'k2, 'd) t -> unit end end module Kn : sig type ('k, 'd) t val make : 'k array -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k array -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k array -> 'd -> unit val remove : ('k, 'd) t -> 'k array -> unit val find : ('k, 'd) t -> 'k array -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end ocaml-stdcompat-20~git20240529/interfaces/5.0/filename.mli000066400000000000000000000016671463722102200230370ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/5.0/float.mli000066400000000000000000000205351463722102200223570ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val mapi : (int -> float -> float) -> t -> t val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a val fold_right : (float -> 'a -> 'a) -> t -> 'a -> 'a val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val mapi : f:(int -> float -> float) -> t -> t val fold_left : f:('a -> float -> 'a) -> init:'a -> t -> 'a val fold_right : f:(float -> 'a -> 'a) -> t -> init:'a -> 'a val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.0/format.mli000066400000000000000000000204171463722102200225410ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_bytes : formatter -> bytes -> unit val print_bytes : bytes -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val synchronized_formatter_of_out_channel : out_channel -> formatter Domain.DLS.key val std_formatter : formatter val get_std_formatter : unit -> formatter val err_formatter : formatter val get_err_formatter : unit -> formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val get_stdbuf : unit -> Buffer.t val str_formatter : formatter val get_str_formatter : unit -> formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val make_synchronized_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter Domain.DLS.key val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/5.0/fun.mli000066400000000000000000000003621463722102200220360ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/5.0/gc.mli000066400000000000000000000045701463722102200216440ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int ; forced_major_collections: int } type control = { minor_heap_size: int ; major_heap_increment: int ; space_overhead: int ; verbose: int ; max_overhead: int ; stack_limit: int ; allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit val eventlog_pause : unit -> unit val eventlog_resume : unit -> unit module Memprof : sig type allocation_source = | Normal | Marshal | Custom type allocation = private { n_samples: int ; size: int ; source: allocation_source ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> unit val stop : unit -> unit end ocaml-stdcompat-20~git20240529/interfaces/5.0/hashtbl.mli000066400000000000000000000126221463722102200226750ustar00rootroot00000000000000type (!'a, !'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/5.0/in_channel.mli000066400000000000000000000016461463722102200233520ustar00rootroot00000000000000type t = in_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdin : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val close : t -> unit val close_noerr : t -> unit val input_char : t -> char option val input_byte : t -> int option val input_line : t -> string option val input : t -> bytes -> int -> int -> int val really_input : t -> bytes -> int -> int -> unit option val really_input_string : t -> int -> string option val input_all : t -> string val set_binary_mode : t -> bool -> unit ocaml-stdcompat-20~git20240529/interfaces/5.0/int32.mli000066400000000000000000000035351463722102200222120ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/5.0/int64.mli000066400000000000000000000041211463722102200222070ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/5.0/lazy.mli000066400000000000000000000004441463722102200222260ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val map : ('a -> 'b) -> 'a t -> 'b t val is_val : 'a t -> bool val from_val : 'a -> 'a t val map_val : ('a -> 'b) -> 'a t -> 'b t val from_fun : (unit -> 'a) -> 'a t val force_val : 'a t -> 'a ocaml-stdcompat-20~git20240529/interfaces/5.0/lexing.mli000066400000000000000000000032651463722102200225410ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/5.0/list.mli000066400000000000000000000061011463722102200222160ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_map : ('a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/5.0/listLabels.mli000066400000000000000000000063111463722102200233440ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/5.0/map.mli000066400000000000000000000101621463722102200220220ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key -> 'a -> 'a t -> 'a t 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 compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val filter : (key -> 'a -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/5.0/marshal.mli000066400000000000000000000011031463722102200226670ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/5.0/moreLabels.mli000066400000000000000000000341341463722102200233370ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val add : key:key -> data:'a -> 'a t -> 'a t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val split : key -> 'a t -> ('a t * 'a option * 'a t) val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : f:(elt -> unit) -> t -> unit val map : f:(elt -> elt) -> t -> t val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/5.0/nativeint.mli000066400000000000000000000040421463722102200232460ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/5.0/obj.mli000066400000000000000000000044441463722102200220250ustar00rootroot00000000000000type t type raw_data = nativeint external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag"[@@noalloc ] external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" external compare_and_swap_field : t -> int -> t -> t -> bool = "caml_obj_compare_and_swap" external is_shared : t -> bool = "caml_obj_is_shared" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external raw_field : t -> int -> raw_data = "caml_obj_raw_field" external set_raw_field : t -> int -> raw_data -> unit = "caml_obj_set_raw_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val forcing_tag : int val cont_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Closure : sig type info = { arity: int ; start_env: int } val info : t -> info end module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/5.0/oo.mli000066400000000000000000000002571463722102200216660ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/5.0/option.mli000066400000000000000000000013331463722102200225550ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/5.0/out_channel.mli000066400000000000000000000020111463722102200235360ustar00rootroot00000000000000type t = out_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdout : t val stderr : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val close : t -> unit val close_noerr : t -> unit val flush : t -> unit val flush_all : unit -> unit val output_char : t -> char -> unit val output_byte : t -> int -> unit val output_string : t -> string -> unit val output_bytes : t -> bytes -> unit val output : t -> bytes -> int -> int -> unit val output_substring : t -> string -> int -> int -> unit val set_binary_mode : t -> bool -> unit val set_buffered : t -> bool -> unit val is_buffered : t -> bool ocaml-stdcompat-20~git20240529/interfaces/5.0/parsing.mli000066400000000000000000000017421463722102200227140ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/5.0/printexc.mli000066400000000000000000000035611463722102200231060ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace type raw_backtrace_entry = private int val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string val string_of_extension_constructor : Obj.t -> string ocaml-stdcompat-20~git20240529/interfaces/5.0/printf.mli000066400000000000000000000015501463722102200225500ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/5.0/queue.mli000066400000000000000000000011161463722102200223700ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/5.0/random.mli000066400000000000000000000017371463722102200225350ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val full_int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool val bits32 : unit -> Int32.t val bits64 : unit -> Int64.t val nativebits : unit -> Nativeint.t module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val full_int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool val bits32 : t -> Int32.t val bits64 : t -> Int64.t val nativebits : t -> Nativeint.t val split : t -> t end val get_state : unit -> State.t val set_state : State.t -> unit val split : unit -> State.t ocaml-stdcompat-20~git20240529/interfaces/5.0/result.mli000066400000000000000000000021341463722102200225630ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/5.0/scanf.mli000066400000000000000000000033331463722102200223410ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c type ('a, 'b, 'c, 'd) scanner_opt = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd option, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val bscanf_opt : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner_opt val sscanf : string -> ('a, 'b, 'c, 'd) scanner val sscanf_opt : string -> ('a, 'b, 'c, 'd) scanner_opt val scanf : ('a, 'b, 'c, 'd) scanner val scanf_opt : ('a, 'b, 'c, 'd) scanner_opt val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string ocaml-stdcompat-20~git20240529/interfaces/5.0/seq.mli000066400000000000000000000046661463722102200220510ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val is_empty : 'a t -> bool val uncons : 'a t -> ('a * 'a t) option val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val iteri : (int -> 'a -> unit) -> 'a t -> unit val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b val for_all : ('a -> bool) -> 'a t -> bool val exists : ('a -> bool) -> 'a t -> bool val find : ('a -> bool) -> 'a t -> 'a option val find_map : ('a -> 'b option) -> 'a t -> 'b option val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val init : int -> (int -> 'a) -> 'a t val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t val repeat : 'a -> 'a t val forever : (unit -> 'a) -> 'a t val cycle : 'a t -> 'a t val iterate : ('a -> 'a) -> 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t val take : int -> 'a t -> 'a t val drop : int -> 'a t -> 'a t val take_while : ('a -> bool) -> 'a t -> 'a t val drop_while : ('a -> bool) -> 'a t -> 'a t val group : ('a -> 'a -> bool) -> 'a t -> 'a t t val memoize : 'a t -> 'a t exception Forced_twice val once : 'a t -> 'a t val transpose : 'a t t -> 'a t t val append : 'a t -> 'a t -> 'a t val concat : 'a t t -> 'a t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val concat_map : ('a -> 'b t) -> 'a t -> 'b t val zip : 'a t -> 'b t -> ('a * 'b) t val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val interleave : 'a t -> 'a t -> 'a t val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t val product : 'a t -> 'b t -> ('a * 'b) t val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val unzip : ('a * 'b) t -> ('a t * 'b t) val split : ('a * 'b) t -> ('a t * 'b t) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> ('b t * 'c t) val partition : ('a -> bool) -> 'a t -> ('a t * 'a t) val of_dispenser : (unit -> 'a option) -> 'a t val to_dispenser : 'a t -> unit -> 'a option val ints : int -> int t ocaml-stdcompat-20~git20240529/interfaces/5.0/set.mli000066400000000000000000000063101463722102200220400ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val is_empty : t -> bool val mem : elt -> t -> bool val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val compare : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val iter : (elt -> unit) -> t -> unit val map : (elt -> elt) -> t -> t val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val split : elt -> t -> (t * bool * t) val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/5.0/stack.mli000066400000000000000000000000011463722102200223410ustar00rootroot00000000000000 ocaml-stdcompat-20~git20240529/interfaces/5.0/stdLabels.mli000066400000000000000000000001541463722102200231620ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/5.0/stdlib.mli000066400000000000000000000276311463722102200225370ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __FUNCTION__ : string = "%loc_FUNCTION" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external \#mod : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external \#land : int -> int -> int = "%andint" external \#lor : int -> int -> int = "%orint" external \#lxor : int -> int -> int = "%xorint" val lnot : int -> int external \#lsl : int -> int -> int = "%lslint" external \#lsr : int -> int -> int = "%lsrint" external \#asr : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit val do_domain_local_at_exit : (unit -> unit) ref module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Atomic = Atomic module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Condition = Condition module Digest = Digest module Domain = Domain module Effect = Effect module Either = Either module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Hashtbl = Hashtbl module In_channel = In_channel module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Mutex = Mutex module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Out_channel = Out_channel module Parsing = Parsing module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Semaphore = Semaphore module Seq = Seq module Set = Set module Stack = Stack module StdLabels = StdLabels module String = String module StringLabels = StringLabels module Sys = Sys module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/5.0/string.mli000066400000000000000000000056751463722102200225700ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> (int -> char) -> string val empty : string val of_bytes : bytes -> string val to_bytes : string -> bytes external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> int -> int -> string val split_on_char : char -> string -> string list val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a val for_all : (char -> bool) -> string -> bool val exists : (char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool val blit : string -> int -> bytes -> int -> int -> unit val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val hash : t -> int val seeded_hash : int -> t -> int val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/5.0/stringLabels.mli000066400000000000000000000057431463722102200237070ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> f:(int -> char) -> string val empty : string val of_bytes : bytes -> string val to_bytes : string -> bytes external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val concat : sep:string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> pos:int -> len:int -> string val split_on_char : sep:char -> string -> string list val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val fold_left : f:('a -> char -> 'a) -> init:'a -> string -> 'a val fold_right : f:(char -> 'a -> 'a) -> string -> init:'a -> 'a val for_all : f:(char -> bool) -> string -> bool val exists : f:(char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val hash : t -> int val seeded_hash : int -> t -> int val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/5.0/sys.mli000066400000000000000000000056401463722102200220700ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val development_version : bool type extra_prefix = | Plus | Tilde type extra_info = (extra_prefix * string) type ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } val ocaml_release : ocaml_release_info val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/5.0/uchar.mli000066400000000000000000000012611463722102200223470ustar00rootroot00000000000000type t[@@immediate ] val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int type utf_decode[@@immediate ] val utf_decode_is_valid : utf_decode -> bool val utf_decode_uchar : utf_decode -> t val utf_decode_length : utf_decode -> int val utf_decode : int -> t -> utf_decode val utf_decode_invalid : int -> utf_decode val utf_8_byte_length : t -> int val utf_16_byte_length : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.0/unit.mli000066400000000000000000000001531463722102200222230ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/5.0/weak.mli000066400000000000000000000026161463722102200222010ustar00rootroot00000000000000type !'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/5.1/000077500000000000000000000000001463722102200205435ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/5.1/arg.mli000066400000000000000000000031031463722102200220140ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/5.1/array.mli000066400000000000000000000055401463722102200223700ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val map_inplace : ('a -> 'a) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val mapi_inplace : (int -> 'a -> 'a) -> 'a array -> unit val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a array -> 'acc val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a array -> ('acc * 'b array) val fold_right : ('a -> 'acc -> 'acc) -> 'a array -> 'acc -> 'acc val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val find_opt : ('a -> bool) -> 'a array -> 'a option val find_index : ('a -> bool) -> 'a array -> int option val find_map : ('a -> 'b option) -> 'a array -> 'b option val find_mapi : (int -> 'a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.1/arrayLabels.mli000066400000000000000000000057471463722102200235240ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val map_inplace : f:('a -> 'a) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val mapi_inplace : f:(int -> 'a -> 'a) -> 'a array -> unit val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a array -> ('acc * 'b array) val fold_right : f:('a -> 'acc -> 'acc) -> 'a array -> init:'acc -> 'acc val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : f:('a -> bool) -> 'a array -> bool val exists : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool val find_opt : f:('a -> bool) -> 'a array -> 'a option val find_index : f:('a -> bool) -> 'a array -> int option val find_map : f:('a -> 'b option) -> 'a array -> 'b option val find_mapi : f:(int -> 'a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.1/atomic.mli000066400000000000000000000003741463722102200225260ustar00rootroot00000000000000type !'a t val make : 'a -> 'a t val get : 'a t -> 'a val set : 'a t -> 'a -> unit val exchange : 'a t -> 'a -> 'a val compare_and_set : 'a t -> 'a -> 'a -> bool val fetch_and_add : int t -> int -> int val incr : int t -> unit val decr : int t -> unit ocaml-stdcompat-20~git20240529/interfaces/5.1/bool.mli000066400000000000000000000005631463722102200222050ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string val seeded_hash : int -> bool -> int val hash : bool -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/buffer.mli000066400000000000000000000027031463722102200225210ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/5.1/bytes.mli000066400000000000000000000105351463722102200224000ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val fold_left : ('acc -> char -> 'acc) -> 'acc -> bytes -> 'acc val fold_right : (char -> 'acc -> 'acc) -> bytes -> 'acc -> 'acc val for_all : (char -> bool) -> bytes -> bool val exists : (char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_escape : bytes -> bytes ocaml-stdcompat-20~git20240529/interfaces/5.1/bytesLabels.mli000066400000000000000000000107441463722102200235250ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> bytes -> 'acc val fold_right : f:(char -> 'acc -> 'acc) -> bytes -> init:'acc -> 'acc val for_all : f:(char -> bool) -> bytes -> bool val exists : f:(char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : sep:char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_escape : bytes -> bytes ocaml-stdcompat-20~git20240529/interfaces/5.1/callback.mli000066400000000000000000000001231463722102200227760ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/5.1/char.mli000066400000000000000000000005161463722102200221650ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool val seeded_hash : int -> t -> int val hash : t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/5.1/complex.mli000066400000000000000000000006021463722102200227130ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/5.1/digest.mli000066400000000000000000000006221463722102200225250ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t external channel : in_channel -> int -> t = "caml_md5_chan" val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val from_hex : string -> t ocaml-stdcompat-20~git20240529/interfaces/5.1/domain.mli000066400000000000000000000007521463722102200225210ustar00rootroot00000000000000type !'a t val spawn : (unit -> 'a) -> 'a t val join : 'a t -> 'a type id = private int val get_id : 'a t -> id val self : unit -> id val before_first_spawn : (unit -> unit) -> unit val at_exit : (unit -> unit) -> unit val cpu_relax : unit -> unit val is_main_domain : unit -> bool val recommended_domain_count : unit -> int module DLS : sig type 'a key val new_key : ?split_from_parent:('a -> 'a) -> (unit -> 'a) -> 'a key val get : 'a key -> 'a val set : 'a key -> 'a -> unit end ocaml-stdcompat-20~git20240529/interfaces/5.1/either.mli000066400000000000000000000015641463722102200225340ustar00rootroot00000000000000type ('a, 'b) t = | Left of 'a | Right of 'b val left : 'a -> ('a, 'b) t val right : 'b -> ('a, 'b) t val is_left : ('a, 'b) t -> bool val is_right : ('a, 'b) t -> bool val find_left : ('a, 'b) t -> 'a option val find_right : ('a, 'b) t -> 'b option val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/ephemeron.mli000066400000000000000000000177041463722102200232410ustar00rootroot00000000000000module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val make : 'k -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k -> 'd -> unit val remove : ('k, 'd) t -> 'k -> unit val find : ('k, 'd) t -> 'k -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end module K2 : sig type ('k1, 'k2, 'd) t val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) t val query : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k1, 'k2, 'd) t val make : unit -> ('k1, 'k2, 'd) t val add : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd -> unit val remove : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> unit val find : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option val length : ('k1, 'k2, 'd) t -> int val clear : ('k1, 'k2, 'd) t -> unit end end module Kn : sig type ('k, 'd) t val make : 'k array -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k array -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k array -> 'd -> unit val remove : ('k, 'd) t -> 'k array -> unit val find : ('k, 'd) t -> 'k array -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end ocaml-stdcompat-20~git20240529/interfaces/5.1/filename.mli000066400000000000000000000020031463722102200230210ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val temp_dir : ?temp_dir:string -> ?perms:int -> string -> string -> string val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/5.1/float.mli000066400000000000000000000221731463722102200223600ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val signaling_nan : float val quiet_nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val seeded_hash : int -> t -> int val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val map_inplace : (float -> float) -> t -> unit val mapi : (int -> float -> float) -> t -> t val mapi_inplace : (int -> float -> float) -> t -> unit val fold_left : ('acc -> float -> 'acc) -> 'acc -> t -> 'acc val fold_right : (float -> 'acc -> 'acc) -> t -> 'acc -> 'acc val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val find_opt : (float -> bool) -> t -> float option val find_index : (float -> bool) -> t -> int option val find_map : (float -> 'a option) -> t -> 'a option val find_mapi : (int -> float -> 'a option) -> t -> 'a option val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val map_inplace : f:(float -> float) -> t -> unit val mapi : f:(int -> float -> float) -> t -> t val mapi_inplace : f:(int -> float -> float) -> t -> unit val fold_left : f:('acc -> float -> 'acc) -> init:'acc -> t -> 'acc val fold_right : f:(float -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val find_opt : f:(float -> bool) -> t -> float option val find_index : f:(float -> bool) -> t -> int option val find_map : f:(float -> 'a option) -> t -> 'a option val find_mapi : f:(int -> float -> 'a option) -> t -> 'a option val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.1/format.mli000066400000000000000000000210501463722102200225340ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_bytes : formatter -> bytes -> unit val print_bytes : bytes -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val synchronized_formatter_of_out_channel : out_channel -> formatter Domain.DLS.key val std_formatter : formatter val get_std_formatter : unit -> formatter val err_formatter : formatter val get_err_formatter : unit -> formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val get_stdbuf : unit -> Buffer.t val str_formatter : formatter val get_str_formatter : unit -> formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val make_synchronized_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter Domain.DLS.key val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_iter : ?pp_sep:(formatter -> unit -> unit) -> (('a -> unit) -> 'b -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'b -> unit val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_array : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a array -> unit val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/5.1/fun.mli000066400000000000000000000003621463722102200220370ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/5.1/gc.mli000066400000000000000000000045701463722102200216450ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int ; forced_major_collections: int } type control = { minor_heap_size: int ; major_heap_increment: int ; space_overhead: int ; verbose: int ; max_overhead: int ; stack_limit: int ; allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit val eventlog_pause : unit -> unit val eventlog_resume : unit -> unit module Memprof : sig type allocation_source = | Normal | Marshal | Custom type allocation = private { n_samples: int ; size: int ; source: allocation_source ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> unit val stop : unit -> unit end ocaml-stdcompat-20~git20240529/interfaces/5.1/hashtbl.mli000066400000000000000000000126721463722102200227030ustar00rootroot00000000000000type (!'a, !'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'acc -> 'acc) -> ('a, 'b) t -> 'acc -> 'acc val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/in_channel.mli000066400000000000000000000020371463722102200233460ustar00rootroot00000000000000type t = in_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdin : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val close : t -> unit val close_noerr : t -> unit val input_char : t -> char option val input_byte : t -> int option val input_line : t -> string option val really_input_string : t -> int -> string option val input_all : t -> string val input_lines : t -> string list val input : t -> bytes -> int -> int -> int val really_input : t -> bytes -> int -> int -> unit option val fold_lines : ('acc -> string -> 'acc) -> 'acc -> t -> 'acc val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val set_binary_mode : t -> bool -> unit val isatty : t -> bool ocaml-stdcompat-20~git20240529/interfaces/5.1/int32.mli000066400000000000000000000036231463722102200222110ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val seeded_hash : int -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/int64.mli000066400000000000000000000042071463722102200222150ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val seeded_hash : int -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/lazy.mli000066400000000000000000000004441463722102200222270ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val map : ('a -> 'b) -> 'a t -> 'b t val is_val : 'a t -> bool val from_val : 'a -> 'a t val map_val : ('a -> 'b) -> 'a t -> 'b t val from_fun : (unit -> 'a) -> 'a t val force_val : 'a t -> 'a ocaml-stdcompat-20~git20240529/interfaces/5.1/lexing.mli000066400000000000000000000032651463722102200225420ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/list.mli000066400000000000000000000064041463722102200222250ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val is_empty : 'a list -> bool val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a list -> ('acc * 'b list) val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a list -> 'b list -> 'acc val fold_right2 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'acc val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_index : ('a -> bool) -> 'a list -> int option val find_map : ('a -> 'b option) -> 'a list -> 'b option val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/5.1/listLabels.mli000066400000000000000000000066141463722102200233530ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val is_empty : 'a list -> bool val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a list -> ('acc * 'b list) val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'acc val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'acc val fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'acc val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_index : f:('a -> bool) -> 'a list -> int option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/5.1/map.mli000066400000000000000000000106361463722102200220310ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +!'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/5.1/marshal.mli000066400000000000000000000011031463722102200226700ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/moreLabels.mli000066400000000000000000000351261463722102200233420ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'acc -> 'acc) -> ('a, 'b) t -> init:'acc -> 'acc val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val add_to_list : key:key -> data:'a -> 'a list t -> 'a list t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val add_to_list : key:key -> data:'a -> 'a list t -> 'a list t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val map : f:(elt -> elt) -> t -> t val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val map : f:(elt -> elt) -> t -> t val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/5.1/nativeint.mli000066400000000000000000000041301463722102200232450ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val seeded_hash : int -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/obj.mli000066400000000000000000000042211463722102200220170ustar00rootroot00000000000000type t type raw_data = nativeint external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag"[@@noalloc ] external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external raw_field : t -> int -> raw_data = "caml_obj_raw_field" external set_raw_field : t -> int -> raw_data -> unit = "caml_obj_set_raw_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val forcing_tag : int val cont_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Closure : sig type info = { arity: int ; start_env: int } val info : t -> info end module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/5.1/oo.mli000066400000000000000000000002571463722102200216670ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/5.1/option.mli000066400000000000000000000013331463722102200225560ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/5.1/out_channel.mli000066400000000000000000000020401463722102200235410ustar00rootroot00000000000000type t = out_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdout : t val stderr : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val close : t -> unit val close_noerr : t -> unit val output_char : t -> char -> unit val output_byte : t -> int -> unit val output_string : t -> string -> unit val output_bytes : t -> bytes -> unit val output : t -> bytes -> int -> int -> unit val output_substring : t -> string -> int -> int -> unit val flush : t -> unit val flush_all : unit -> unit val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val set_binary_mode : t -> bool -> unit val set_buffered : t -> bool -> unit val is_buffered : t -> bool val isatty : t -> bool ocaml-stdcompat-20~git20240529/interfaces/5.1/parsing.mli000066400000000000000000000017421463722102200227150ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/5.1/printexc.mli000066400000000000000000000035611463722102200231070ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace type raw_backtrace_entry = private int val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string val string_of_extension_constructor : Obj.t -> string ocaml-stdcompat-20~git20240529/interfaces/5.1/printf.mli000066400000000000000000000015501463722102200225510ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/5.1/queue.mli000066400000000000000000000011261463722102200223720ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/5.1/random.mli000066400000000000000000000020511463722102200225240ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val full_int : int -> int val int32 : Int32.t -> Int32.t val nativeint : Nativeint.t -> Nativeint.t val int64 : Int64.t -> Int64.t val float : float -> float val bool : unit -> bool val bits32 : unit -> Int32.t val bits64 : unit -> Int64.t val nativebits : unit -> Nativeint.t module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val full_int : t -> int -> int val int32 : t -> Int32.t -> Int32.t val nativeint : t -> Nativeint.t -> Nativeint.t val int64 : t -> Int64.t -> Int64.t val float : t -> float -> float val bool : t -> bool val bits32 : t -> Int32.t val bits64 : t -> Int64.t val nativebits : t -> Nativeint.t val split : t -> t val to_binary_string : t -> string val of_binary_string : string -> t end val get_state : unit -> State.t val set_state : State.t -> unit val split : unit -> State.t ocaml-stdcompat-20~git20240529/interfaces/5.1/result.mli000066400000000000000000000021341463722102200225640ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/5.1/scanf.mli000066400000000000000000000033331463722102200223420ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c type ('a, 'b, 'c, 'd) scanner_opt = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd option, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val bscanf_opt : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner_opt val sscanf : string -> ('a, 'b, 'c, 'd) scanner val sscanf_opt : string -> ('a, 'b, 'c, 'd) scanner_opt val scanf : ('a, 'b, 'c, 'd) scanner val scanf_opt : ('a, 'b, 'c, 'd) scanner_opt val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string ocaml-stdcompat-20~git20240529/interfaces/5.1/seq.mli000066400000000000000000000051001463722102200220320ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val is_empty : 'a t -> bool val uncons : 'a t -> ('a * 'a t) option val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val iteri : (int -> 'a -> unit) -> 'a t -> unit val fold_lefti : ('acc -> int -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val for_all : ('a -> bool) -> 'a t -> bool val exists : ('a -> bool) -> 'a t -> bool val find : ('a -> bool) -> 'a t -> 'a option val find_index : ('a -> bool) -> 'a t -> int option val find_map : ('a -> 'b option) -> 'a t -> 'b option val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val init : int -> (int -> 'a) -> 'a t val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t val repeat : 'a -> 'a t val forever : (unit -> 'a) -> 'a t val cycle : 'a t -> 'a t val iterate : ('a -> 'a) -> 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t val take : int -> 'a t -> 'a t val drop : int -> 'a t -> 'a t val take_while : ('a -> bool) -> 'a t -> 'a t val drop_while : ('a -> bool) -> 'a t -> 'a t val group : ('a -> 'a -> bool) -> 'a t -> 'a t t val memoize : 'a t -> 'a t exception Forced_twice val once : 'a t -> 'a t val transpose : 'a t t -> 'a t t val append : 'a t -> 'a t -> 'a t val concat : 'a t t -> 'a t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val concat_map : ('a -> 'b t) -> 'a t -> 'b t val zip : 'a t -> 'b t -> ('a * 'b) t val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val interleave : 'a t -> 'a t -> 'a t val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t val product : 'a t -> 'b t -> ('a * 'b) t val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val unzip : ('a * 'b) t -> ('a t * 'b t) val split : ('a * 'b) t -> ('a t * 'b t) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> ('b t * 'c t) val partition : ('a -> bool) -> 'a t -> ('a t * 'a t) val of_dispenser : (unit -> 'a option) -> 'a t val to_dispenser : 'a t -> unit -> 'a option val ints : int -> int t ocaml-stdcompat-20~git20240529/interfaces/5.1/set.mli000066400000000000000000000064301463722102200220440ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/5.1/stack.mli000066400000000000000000000007771463722102200223660ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val drop : 'a t -> unit val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/5.1/stdLabels.mli000066400000000000000000000001541463722102200231630ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/5.1/stdlib.mli000066400000000000000000000276541463722102200225450ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __FUNCTION__ : string = "%loc_FUNCTION" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external \#mod : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external \#land : int -> int -> int = "%andint" external \#lor : int -> int -> int = "%orint" external \#lxor : int -> int -> int = "%xorint" val lnot : int -> int external \#lsl : int -> int -> int = "%lslint" external \#lsr : int -> int -> int = "%lsrint" external \#asr : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit val do_domain_local_at_exit : (unit -> unit) ref module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Atomic = Atomic module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Condition = Condition module Digest = Digest module Domain = Domain module Effect = Effect module Either = Either module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Hashtbl = Hashtbl module In_channel = In_channel module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Mutex = Mutex module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Out_channel = Out_channel module Parsing = Parsing module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Semaphore = Semaphore module Seq = Seq module Set = Set module Stack = Stack module StdLabels = StdLabels module String = String module StringLabels = StringLabels module Sys = Sys module Type = Type module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/5.1/string.mli000066400000000000000000000057151463722102200225640ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> (int -> char) -> string val empty : string external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val of_bytes : bytes -> string val to_bytes : string -> bytes val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> int -> int -> string val split_on_char : char -> string -> string list val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc val for_all : (char -> bool) -> string -> bool val exists : (char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val hash : t -> int val seeded_hash : int -> t -> int val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/5.1/stringLabels.mli000066400000000000000000000057631463722102200237120ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> f:(int -> char) -> string val empty : string external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val of_bytes : bytes -> string val to_bytes : string -> bytes val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> pos:int -> len:int -> string val split_on_char : sep:char -> string -> string list val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> string -> 'acc val fold_right : f:(char -> 'acc -> 'acc) -> string -> init:'acc -> 'acc val for_all : f:(char -> bool) -> string -> bool val exists : f:(char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val hash : t -> int val seeded_hash : int -> t -> int val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/5.1/sys.mli000066400000000000000000000057471463722102200221010ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external is_regular_file : string -> bool = "caml_sys_is_regular_file" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val development_version : bool type extra_prefix = | Plus | Tilde type extra_info = (extra_prefix * string) type ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } val ocaml_release : ocaml_release_info val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/5.1/uchar.mli000066400000000000000000000012611463722102200223500ustar00rootroot00000000000000type t[@@immediate ] val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int type utf_decode[@@immediate ] val utf_decode_is_valid : utf_decode -> bool val utf_decode_uchar : utf_decode -> t val utf_decode_length : utf_decode -> int val utf_decode : int -> t -> utf_decode val utf_decode_invalid : int -> utf_decode val utf_8_byte_length : t -> int val utf_16_byte_length : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.1/unit.mli000066400000000000000000000001531463722102200222240ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/5.1/weak.mli000066400000000000000000000026361463722102200222040ustar00rootroot00000000000000type !'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/interfaces/5.2/000077500000000000000000000000001463722102200205445ustar00rootroot00000000000000ocaml-stdcompat-20~git20240529/interfaces/5.2/arg.mli000066400000000000000000000031031463722102200220150ustar00rootroot00000000000000type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit exception Help of string exception Bad of string val usage : (key * spec * doc) list -> usage_msg -> unit val usage_string : (key * spec * doc) list -> usage_msg -> string val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list val current : int ref val read_arg : string -> string array val read_arg0 : string -> string array val write_arg : string -> string array -> unit val write_arg0 : string -> string array -> unit ocaml-stdcompat-20~git20240529/interfaces/5.2/array.mli000066400000000000000000000057311463722102200223730ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val init : int -> (int -> 'a) -> 'a array val make_matrix : int -> int -> 'a -> 'a array array val init_matrix : int -> int -> (int -> int -> 'a) -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> int -> int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> int -> int -> 'a -> unit val blit : 'a array -> int -> 'a array -> int -> int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : ('a -> unit) -> 'a array -> unit val iteri : (int -> 'a -> unit) -> 'a array -> unit val map : ('a -> 'b) -> 'a array -> 'b array val map_inplace : ('a -> 'a) -> 'a array -> unit val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array val mapi_inplace : (int -> 'a -> 'a) -> 'a array -> unit val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a array -> 'acc val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a array -> ('acc * 'b array) val fold_right : ('a -> 'acc -> 'acc) -> 'a array -> 'acc -> 'acc val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : ('a -> bool) -> 'a array -> bool val exists : ('a -> bool) -> 'a array -> bool val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> 'a array -> bool val memq : 'a -> 'a array -> bool val find_opt : ('a -> bool) -> 'a array -> 'a option val find_index : ('a -> bool) -> 'a array -> int option val find_map : ('a -> 'b option) -> 'a array -> 'b option val find_mapi : (int -> 'a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : ('a -> 'a -> int) -> 'a array -> unit val stable_sort : ('a -> 'a -> int) -> 'a array -> unit val fast_sort : ('a -> 'a -> int) -> 'a array -> unit val shuffle : rand:(int -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.2/arrayLabels.mli000066400000000000000000000061561463722102200235200ustar00rootroot00000000000000type 'a t = 'a array external length : 'a array -> int = "%array_length" external get : 'a array -> int -> 'a = "%array_safe_get" external set : 'a array -> int -> 'a -> unit = "%array_safe_set" external make : int -> 'a -> 'a array = "caml_make_vect" external create_float : int -> float array = "caml_make_float_vect" val init : int -> f:(int -> 'a) -> 'a array val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> 'a) -> 'a array array val append : 'a array -> 'a array -> 'a array val concat : 'a array list -> 'a array val sub : 'a array -> pos:int -> len:int -> 'a array val copy : 'a array -> 'a array val fill : 'a array -> pos:int -> len:int -> 'a -> unit val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit val to_list : 'a array -> 'a list val of_list : 'a list -> 'a array val iter : f:('a -> unit) -> 'a array -> unit val iteri : f:(int -> 'a -> unit) -> 'a array -> unit val map : f:('a -> 'b) -> 'a array -> 'b array val map_inplace : f:('a -> 'a) -> 'a array -> unit val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array val mapi_inplace : f:(int -> 'a -> 'a) -> 'a array -> unit val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a array -> ('acc * 'b array) val fold_right : f:('a -> 'acc -> 'acc) -> 'a array -> init:'acc -> 'acc val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array val for_all : f:('a -> bool) -> 'a array -> bool val exists : f:('a -> bool) -> 'a array -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool val mem : 'a -> set:'a array -> bool val memq : 'a -> set:'a array -> bool val find_opt : f:('a -> bool) -> 'a array -> 'a option val find_index : f:('a -> bool) -> 'a array -> int option val find_map : f:('a -> 'b option) -> 'a array -> 'b option val find_mapi : f:(int -> 'a -> 'b option) -> 'a array -> 'b option val split : ('a * 'b) array -> ('a array * 'b array) val combine : 'a array -> 'b array -> ('a * 'b) array val sort : cmp:('a -> 'a -> int) -> 'a array -> unit val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit val shuffle : rand:(int -> int) -> 'a array -> unit val to_seq : 'a array -> 'a Seq.t val to_seqi : 'a array -> (int * 'a) Seq.t val of_seq : 'a Seq.t -> 'a array external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" module Floatarray : sig external create : int -> floatarray = "caml_floatarray_create" external length : floatarray -> int = "%floatarray_length" external get : floatarray -> int -> float = "%floatarray_safe_get" external set : floatarray -> int -> float -> unit = "%floatarray_safe_set" external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.2/atomic.mli000066400000000000000000000004341463722102200225240ustar00rootroot00000000000000type !'a t val make : 'a -> 'a t val make_contended : 'a -> 'a t val get : 'a t -> 'a val set : 'a t -> 'a -> unit val exchange : 'a t -> 'a -> 'a val compare_and_set : 'a t -> 'a -> 'a -> bool val fetch_and_add : int t -> int -> int val incr : int t -> unit val decr : int t -> unit ocaml-stdcompat-20~git20240529/interfaces/5.2/bool.mli000066400000000000000000000005631463722102200222060ustar00rootroot00000000000000type t = bool = | false | true val not : bool -> bool external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" val equal : bool -> bool -> bool val compare : bool -> bool -> int val to_int : bool -> int val to_float : bool -> float val to_string : bool -> string val seeded_hash : int -> bool -> int val hash : bool -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/buffer.mli000066400000000000000000000027031463722102200225220ustar00rootroot00000000000000type t val create : int -> t val contents : t -> string val to_bytes : t -> bytes val sub : t -> int -> int -> string val blit : t -> int -> bytes -> int -> int -> unit val nth : t -> int -> char val length : t -> int val clear : t -> unit val reset : t -> unit val output_buffer : out_channel -> t -> unit val truncate : t -> int -> unit val add_char : t -> char -> unit val add_utf_8_uchar : t -> Uchar.t -> unit val add_utf_16le_uchar : t -> Uchar.t -> unit val add_utf_16be_uchar : t -> Uchar.t -> unit val add_string : t -> string -> unit val add_bytes : t -> bytes -> unit val add_substring : t -> string -> int -> int -> unit val add_subbytes : t -> bytes -> int -> int -> unit val add_substitute : t -> (string -> string) -> string -> unit val add_buffer : t -> t -> unit val add_channel : t -> in_channel -> int -> unit val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val add_seq : t -> char Seq.t -> unit val of_seq : char Seq.t -> t val add_uint8 : t -> int -> unit val add_int8 : t -> int -> unit val add_uint16_ne : t -> int -> unit val add_uint16_be : t -> int -> unit val add_uint16_le : t -> int -> unit val add_int16_ne : t -> int -> unit val add_int16_be : t -> int -> unit val add_int16_le : t -> int -> unit val add_int32_ne : t -> int32 -> unit val add_int32_be : t -> int32 -> unit val add_int32_le : t -> int32 -> unit val add_int64_ne : t -> int64 -> unit val add_int64_be : t -> int64 -> unit val add_int64_le : t -> int64 -> unit ocaml-stdcompat-20~git20240529/interfaces/5.2/bytes.mli000066400000000000000000000105351463722102200224010ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> (int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> int -> int -> bytes val sub_string : bytes -> int -> int -> string val extend : bytes -> int -> int -> bytes val fill : bytes -> int -> int -> char -> unit val blit : bytes -> int -> bytes -> int -> int -> unit val blit_string : string -> int -> bytes -> int -> int -> unit val concat : bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : (char -> unit) -> bytes -> unit val iteri : (int -> char -> unit) -> bytes -> unit val map : (char -> char) -> bytes -> bytes val mapi : (int -> char -> char) -> bytes -> bytes val fold_left : ('acc -> char -> 'acc) -> 'acc -> bytes -> 'acc val fold_right : (char -> 'acc -> 'acc) -> bytes -> 'acc -> 'acc val for_all : (char -> bool) -> bytes -> bool val exists : (char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_escape : bytes -> bytes ocaml-stdcompat-20~git20240529/interfaces/5.2/bytesLabels.mli000066400000000000000000000107441463722102200235260ustar00rootroot00000000000000external length : bytes -> int = "%bytes_length" external get : bytes -> int -> char = "%bytes_safe_get" external set : bytes -> int -> char -> unit = "%bytes_safe_set" external create : int -> bytes = "caml_create_bytes" val make : int -> char -> bytes val init : int -> f:(int -> char) -> bytes val empty : bytes val copy : bytes -> bytes val of_string : string -> bytes val to_string : bytes -> string val sub : bytes -> pos:int -> len:int -> bytes val sub_string : bytes -> pos:int -> len:int -> string val extend : bytes -> left:int -> right:int -> bytes val fill : bytes -> pos:int -> len:int -> char -> unit val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:bytes -> bytes list -> bytes val cat : bytes -> bytes -> bytes val iter : f:(char -> unit) -> bytes -> unit val iteri : f:(int -> char -> unit) -> bytes -> unit val map : f:(char -> char) -> bytes -> bytes val mapi : f:(int -> char -> char) -> bytes -> bytes val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> bytes -> 'acc val fold_right : f:(char -> 'acc -> 'acc) -> bytes -> init:'acc -> 'acc val for_all : f:(char -> bool) -> bytes -> bool val exists : f:(char -> bool) -> bytes -> bool val trim : bytes -> bytes val escaped : bytes -> bytes val index : bytes -> char -> int val index_opt : bytes -> char -> int option val rindex : bytes -> char -> int val rindex_opt : bytes -> char -> int option val index_from : bytes -> int -> char -> int val index_from_opt : bytes -> int -> char -> int option val rindex_from : bytes -> int -> char -> int val rindex_from_opt : bytes -> int -> char -> int option val contains : bytes -> char -> bool val contains_from : bytes -> int -> char -> bool val rcontains_from : bytes -> int -> char -> bool val uppercase_ascii : bytes -> bytes val lowercase_ascii : bytes -> bytes val capitalize_ascii : bytes -> bytes val uncapitalize_ascii : bytes -> bytes type t = bytes val compare : t -> t -> int val equal : t -> t -> bool val starts_with : prefix:bytes -> bytes -> bool val ends_with : suffix:bytes -> bytes -> bool val unsafe_to_string : bytes -> string val unsafe_of_string : string -> bytes val split_on_char : sep:char -> bytes -> bytes list val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val set_utf_8_uchar : t -> int -> Uchar.t -> int val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val set_utf_16be_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val set_utf_16le_uchar : t -> int -> Uchar.t -> int val is_valid_utf_16le : t -> bool val get_uint8 : bytes -> int -> int val get_int8 : bytes -> int -> int val get_uint16_ne : bytes -> int -> int val get_uint16_be : bytes -> int -> int val get_uint16_le : bytes -> int -> int val get_int16_ne : bytes -> int -> int val get_int16_be : bytes -> int -> int val get_int16_le : bytes -> int -> int val get_int32_ne : bytes -> int -> int32 val get_int32_be : bytes -> int -> int32 val get_int32_le : bytes -> int -> int32 val get_int64_ne : bytes -> int -> int64 val get_int64_be : bytes -> int -> int64 val get_int64_le : bytes -> int -> int64 val set_uint8 : bytes -> int -> int -> unit val set_int8 : bytes -> int -> int -> unit val set_uint16_ne : bytes -> int -> int -> unit val set_uint16_be : bytes -> int -> int -> unit val set_uint16_le : bytes -> int -> int -> unit val set_int16_ne : bytes -> int -> int -> unit val set_int16_be : bytes -> int -> int -> unit val set_int16_le : bytes -> int -> int -> unit val set_int32_ne : bytes -> int -> int32 -> unit val set_int32_be : bytes -> int -> int32 -> unit val set_int32_le : bytes -> int -> int32 -> unit val set_int64_ne : bytes -> int -> int64 -> unit val set_int64_be : bytes -> int -> int64 -> unit val set_int64_le : bytes -> int -> int64 -> unit external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] val unsafe_escape : bytes -> bytes ocaml-stdcompat-20~git20240529/interfaces/5.2/callback.mli000066400000000000000000000001231463722102200227770ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit ocaml-stdcompat-20~git20240529/interfaces/5.2/char.mli000066400000000000000000000005161463722102200221660ustar00rootroot00000000000000external code : char -> int = "%identity" val chr : int -> char val escaped : char -> string val lowercase_ascii : char -> char val uppercase_ascii : char -> char type t = char val compare : t -> t -> int val equal : t -> t -> bool val seeded_hash : int -> t -> int val hash : t -> int external unsafe_chr : int -> char = "%identity" ocaml-stdcompat-20~git20240529/interfaces/5.2/complex.mli000066400000000000000000000006021463722102200227140ustar00rootroot00000000000000type t = { re: float ; im: float } val zero : t val one : t val i : t val neg : t -> t val conj : t -> t val add : t -> t -> t val sub : t -> t -> t val mul : t -> t -> t val inv : t -> t val div : t -> t -> t val sqrt : t -> t val norm2 : t -> float val norm : t -> float val arg : t -> float val polar : float -> float -> t val exp : t -> t val log : t -> t val pow : t -> t -> t ocaml-stdcompat-20~git20240529/interfaces/5.2/digest.mli000066400000000000000000000017031463722102200225270ustar00rootroot00000000000000type t = string val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t val channel : in_channel -> int -> t val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t val from_hex : string -> t module type S = sig type t = string val hash_length : int val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t val channel : in_channel -> int -> t val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t end module BLAKE128 : S module BLAKE256 : S module BLAKE512 : S module MD5 : S ocaml-stdcompat-20~git20240529/interfaces/5.2/domain.mli000066400000000000000000000007521463722102200225220ustar00rootroot00000000000000type !'a t val spawn : (unit -> 'a) -> 'a t val join : 'a t -> 'a type id = private int val get_id : 'a t -> id val self : unit -> id val before_first_spawn : (unit -> unit) -> unit val at_exit : (unit -> unit) -> unit val cpu_relax : unit -> unit val is_main_domain : unit -> bool val recommended_domain_count : unit -> int module DLS : sig type 'a key val new_key : ?split_from_parent:('a -> 'a) -> (unit -> 'a) -> 'a key val get : 'a key -> 'a val set : 'a key -> 'a -> unit end ocaml-stdcompat-20~git20240529/interfaces/5.2/either.mli000066400000000000000000000015641463722102200225350ustar00rootroot00000000000000type ('a, 'b) t = | Left of 'a | Right of 'b val left : 'a -> ('a, 'b) t val right : 'b -> ('a, 'b) t val is_left : ('a, 'b) t -> bool val is_right : ('a, 'b) t -> bool val find_left : ('a, 'b) t -> 'a option val find_right : ('a, 'b) t -> 'b option val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/ephemeron.mli000066400000000000000000000177041463722102200232420ustar00rootroot00000000000000module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module K1 : sig type ('k, 'd) t val make : 'k -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k -> 'd -> unit val remove : ('k, 'd) t -> 'k -> unit val find : ('k, 'd) t -> 'k -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end module K2 : sig type ('k1, 'k2, 'd) t val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) t val query : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H1 : Hashtbl.SeededHashedType) -> functor (H2 : Hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k1, 'k2, 'd) t val make : unit -> ('k1, 'k2, 'd) t val add : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd -> unit val remove : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> unit val find : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option val length : ('k1, 'k2, 'd) t -> int val clear : ('k1, 'k2, 'd) t -> unit end end module Kn : sig type ('k, 'd) t val make : 'k array -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k array -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module MakeSeeded : functor (H : Hashtbl.SeededHashedType) -> sig type key = H.t array type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k array -> 'd -> unit val remove : ('k, 'd) t -> 'k array -> unit val find : ('k, 'd) t -> 'k array -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end ocaml-stdcompat-20~git20240529/interfaces/5.2/filename.mli000066400000000000000000000020031463722102200230220ustar00rootroot00000000000000val current_dir_name : string val parent_dir_name : string val dir_sep : string val concat : string -> string -> string val is_relative : string -> bool val is_implicit : string -> bool val check_suffix : string -> string -> bool val chop_suffix : string -> string -> string val chop_suffix_opt : suffix:string -> string -> string option val extension : string -> string val remove_extension : string -> string val chop_extension : string -> string val basename : string -> string val dirname : string -> string val null : string val temp_file : ?temp_dir:string -> string -> string -> string val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) val temp_dir : ?temp_dir:string -> ?perms:int -> string -> string -> string val get_temp_dir_name : unit -> string val set_temp_dir_name : string -> unit val quote : string -> string val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string ocaml-stdcompat-20~git20240529/interfaces/5.2/float.mli000066400000000000000000000227371463722102200223670ustar00rootroot00000000000000val zero : float val one : float val minus_one : float external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] val succ : float -> float val pred : float -> float external abs : float -> float = "%absfloat" val infinity : float val neg_infinity : float val nan : float val signaling_nan : float val quiet_nan : float val pi : float val max_float : float val min_float : float val epsilon : float val is_finite : float -> bool val is_infinite : float -> bool val is_nan : float -> bool val is_integer : float -> bool external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" external of_string : string -> float = "caml_float_of_string" val of_string_opt : string -> float option val to_string : float -> string type fpclass = fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" type t = float val compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : float -> float -> float val min_max : float -> float -> (float * float) val min_num : t -> t -> t val max_num : t -> t -> t val min_max_num : float -> float -> (float * float) val seeded_hash : int -> t -> int val hash : t -> int module Array : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val make_matrix : int -> int -> float -> t array val init_matrix : int -> int -> (int -> int -> float) -> t array val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val map_inplace : (float -> float) -> t -> unit val mapi : (int -> float -> float) -> t -> t val mapi_inplace : (int -> float -> float) -> t -> unit val fold_left : ('acc -> float -> 'acc) -> 'acc -> t -> 'acc val fold_right : (float -> 'acc -> 'acc) -> t -> 'acc -> 'acc val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val find_opt : (float -> bool) -> t -> float option val find_index : (float -> bool) -> t -> int option val find_map : (float -> 'a option) -> t -> 'a option val find_mapi : (int -> float -> 'a option) -> t -> 'a option val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val shuffle : rand:(int -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end module ArrayLabels : sig type t = floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val make_matrix : dimx:int -> dimy:int -> float -> t array val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> float) -> t array val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val map_inplace : f:(float -> float) -> t -> unit val mapi : f:(int -> float -> float) -> t -> t val mapi_inplace : f:(int -> float -> float) -> t -> unit val fold_left : f:('acc -> float -> 'acc) -> init:'acc -> t -> 'acc val fold_right : f:(float -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val find_opt : f:(float -> bool) -> t -> float option val find_index : f:(float -> bool) -> t -> int option val find_map : f:(float -> 'a option) -> t -> 'a option val find_mapi : f:(int -> float -> 'a option) -> t -> 'a option val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val shuffle : rand:(int -> int) -> t -> unit val to_seq : t -> float Seq.t val to_seqi : t -> (int * float) Seq.t val of_seq : float Seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : t -> int -> float = "%floatarray_unsafe_get" external unsafe_set : t -> int -> float -> unit = "%floatarray_unsafe_set" end ocaml-stdcompat-20~git20240529/interfaces/5.2/format.mli000066400000000000000000000211571463722102200225450ustar00rootroot00000000000000type formatter val pp_open_box : formatter -> int -> unit val open_box : int -> unit val pp_close_box : formatter -> unit -> unit val close_box : unit -> unit val pp_open_hbox : formatter -> unit -> unit val open_hbox : unit -> unit val pp_open_vbox : formatter -> int -> unit val open_vbox : int -> unit val pp_open_hvbox : formatter -> int -> unit val open_hvbox : int -> unit val pp_open_hovbox : formatter -> int -> unit val open_hovbox : int -> unit val pp_print_string : formatter -> string -> unit val print_string : string -> unit val pp_print_bytes : formatter -> bytes -> unit val print_bytes : bytes -> unit val pp_print_as : formatter -> int -> string -> unit val print_as : int -> string -> unit val pp_print_int : formatter -> int -> unit val print_int : int -> unit val pp_print_float : formatter -> float -> unit val print_float : float -> unit val pp_print_char : formatter -> char -> unit val print_char : char -> unit val pp_print_bool : formatter -> bool -> unit val print_bool : bool -> unit val pp_print_nothing : formatter -> unit -> unit val pp_print_space : formatter -> unit -> unit val print_space : unit -> unit val pp_print_cut : formatter -> unit -> unit val print_cut : unit -> unit val pp_print_break : formatter -> int -> int -> unit val print_break : int -> int -> unit val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit val pp_force_newline : formatter -> unit -> unit val force_newline : unit -> unit val pp_print_if_newline : formatter -> unit -> unit val print_if_newline : unit -> unit val pp_print_flush : formatter -> unit -> unit val print_flush : unit -> unit val pp_print_newline : formatter -> unit -> unit val print_newline : unit -> unit val pp_infinity : int val pp_set_margin : formatter -> int -> unit val set_margin : int -> unit val pp_get_margin : formatter -> unit -> int val get_margin : unit -> int val pp_set_max_indent : formatter -> int -> unit val set_max_indent : int -> unit val pp_get_max_indent : formatter -> unit -> int val get_max_indent : unit -> int type geometry = { max_indent: int ; margin: int } val check_geometry : geometry -> bool val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit val set_geometry : max_indent:int -> margin:int -> unit val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit val safe_set_geometry : max_indent:int -> margin:int -> unit val pp_update_geometry : formatter -> (geometry -> geometry) -> unit val update_geometry : (geometry -> geometry) -> unit val pp_get_geometry : formatter -> unit -> geometry val get_geometry : unit -> geometry val pp_set_max_boxes : formatter -> int -> unit val set_max_boxes : int -> unit val pp_get_max_boxes : formatter -> unit -> int val get_max_boxes : unit -> int val pp_over_max_boxes : formatter -> unit -> bool val over_max_boxes : unit -> bool val pp_open_tbox : formatter -> unit -> unit val open_tbox : unit -> unit val pp_close_tbox : formatter -> unit -> unit val close_tbox : unit -> unit val pp_set_tab : formatter -> unit -> unit val set_tab : unit -> unit val pp_print_tab : formatter -> unit -> unit val print_tab : unit -> unit val pp_print_tbreak : formatter -> int -> int -> unit val print_tbreak : int -> int -> unit val pp_set_ellipsis_text : formatter -> string -> unit val set_ellipsis_text : string -> unit val pp_get_ellipsis_text : formatter -> unit -> string val get_ellipsis_text : unit -> string type stag = .. type tag = string type stag += | String_tag of tag val pp_open_stag : formatter -> stag -> unit val open_stag : stag -> unit val pp_close_stag : formatter -> unit -> unit val close_stag : unit -> unit val pp_set_tags : formatter -> bool -> unit val set_tags : bool -> unit val pp_set_print_tags : formatter -> bool -> unit val set_print_tags : bool -> unit val pp_set_mark_tags : formatter -> bool -> unit val set_mark_tags : bool -> unit val pp_get_print_tags : formatter -> unit -> bool val get_print_tags : unit -> bool val pp_get_mark_tags : formatter -> unit -> bool val get_mark_tags : unit -> bool val pp_set_formatter_out_channel : formatter -> out_channel -> unit val set_formatter_out_channel : out_channel -> unit val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit val set_formatter_out_functions : formatter_out_functions -> unit val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions val get_formatter_out_functions : unit -> formatter_out_functions type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit val set_formatter_stag_functions : formatter_stag_functions -> unit val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions val get_formatter_stag_functions : unit -> formatter_stag_functions val formatter_of_out_channel : out_channel -> formatter val synchronized_formatter_of_out_channel : out_channel -> formatter Domain.DLS.key val std_formatter : formatter val get_std_formatter : unit -> formatter val err_formatter : formatter val get_err_formatter : unit -> formatter val formatter_of_buffer : Buffer.t -> formatter val stdbuf : Buffer.t val get_stdbuf : unit -> Buffer.t val str_formatter : formatter val get_str_formatter : unit -> formatter val flush_str_formatter : unit -> string val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter val make_synchronized_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter Domain.DLS.key val formatter_of_out_functions : formatter_out_functions -> formatter type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int type symbolic_output_buffer val make_symbolic_output_buffer : unit -> symbolic_output_buffer val clear_symbolic_output_buffer : symbolic_output_buffer -> unit val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter val pp_print_iter : ?pp_sep:(formatter -> unit -> unit) -> (('a -> unit) -> 'b -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'b -> unit val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit val pp_print_array : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a array -> unit val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit val pp_print_text : formatter -> string -> unit val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit val fprintf : formatter -> ('a, formatter, unit) format -> 'a val printf : ('a, formatter, unit) format -> 'a val eprintf : ('a, formatter, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val asprintf : ('a, formatter, unit, string) format4 -> 'a val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a val ifprintf : formatter -> ('a, formatter, unit) format -> 'a val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b ocaml-stdcompat-20~git20240529/interfaces/5.2/fun.mli000066400000000000000000000004451463722102200220420ustar00rootroot00000000000000external id : 'a -> 'a = "%identity" val const : 'a -> 'b -> 'a val compose : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c val negate : ('a -> bool) -> 'a -> bool val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a exception Finally_raised of exn ocaml-stdcompat-20~git20240529/interfaces/5.2/gc.mli000066400000000000000000000046301463722102200216430ustar00rootroot00000000000000type stat = { minor_words: float ; promoted_words: float ; major_words: float ; minor_collections: int ; major_collections: int ; heap_words: int ; heap_chunks: int ; live_words: int ; live_blocks: int ; free_words: int ; free_blocks: int ; largest_free: int ; fragments: int ; compactions: int ; top_heap_words: int ; stack_size: int ; forced_major_collections: int } type control = { minor_heap_size: int ; major_heap_increment: int ; space_overhead: int ; verbose: int ; max_overhead: int ; stack_limit: int ; allocation_policy: int ; window_size: int ; custom_major_ratio: int ; custom_minor_ratio: int ; custom_minor_max_size: int } external stat : unit -> stat = "caml_gc_stat" external quick_stat : unit -> stat = "caml_gc_quick_stat" external counters : unit -> (float * float * float) = "caml_gc_counters" external minor_words : unit -> ((float)[@unboxed ]) = "caml_gc_minor_words" "caml_gc_minor_words_unboxed" external get : unit -> control = "caml_gc_get" external set : control -> unit = "caml_gc_set" external minor : unit -> unit = "caml_gc_minor" external major_slice : int -> int = "caml_gc_major_slice" external major : unit -> unit = "caml_gc_major" external full_major : unit -> unit = "caml_gc_full_major" external compact : unit -> unit = "caml_gc_compaction" val print_stat : out_channel -> unit val allocated_bytes : unit -> float external get_minor_free : unit -> int = "caml_get_minor_free" val finalise : ('a -> unit) -> 'a -> unit val finalise_last : (unit -> unit) -> 'a -> unit val finalise_release : unit -> unit type alarm val create_alarm : (unit -> unit) -> alarm val delete_alarm : alarm -> unit val eventlog_pause : unit -> unit val eventlog_resume : unit -> unit module Memprof : sig type t type allocation_source = | Normal | Marshal | Custom type allocation = private { n_samples: int ; size: int ; source: allocation_source ; callstack: Printexc.raw_backtrace } type ('minor, 'major) tracker = { alloc_minor: allocation -> 'minor option ; alloc_major: allocation -> 'major option ; promote: 'minor -> 'major option ; dealloc_minor: 'minor -> unit ; dealloc_major: 'major -> unit } val null_tracker : ('minor, 'major) tracker val start : sampling_rate:float -> ?callstack_size:int -> ('minor, 'major) tracker -> t val stop : unit -> unit val discard : t -> unit end ocaml-stdcompat-20~git20240529/interfaces/5.2/hashtbl.mli000066400000000000000000000126721463722102200227040ustar00rootroot00000000000000type (!'a, !'b) t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> 'a -> 'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> 'a -> 'b -> unit val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit val fold : ('a -> 'b -> 'acc -> 'acc) -> ('a, 'b) t -> 'acc -> 'acc val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/in_channel.mli000066400000000000000000000025171463722102200233520ustar00rootroot00000000000000type t = in_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdin : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val close : t -> unit val close_noerr : t -> unit val input_char : t -> char option val input_byte : t -> int option val input_line : t -> string option val really_input_string : t -> int -> string option val input_all : t -> string val input_lines : t -> string list val input : t -> bytes -> int -> int -> int val input_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> int val really_input : t -> bytes -> int -> int -> unit option val really_input_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> unit option val fold_lines : ('acc -> string -> 'acc) -> 'acc -> t -> 'acc val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val set_binary_mode : t -> bool -> unit val is_binary_mode : t -> bool val isatty : t -> bool ocaml-stdcompat-20~git20240529/interfaces/5.2/int32.mli000066400000000000000000000036231463722102200222120ustar00rootroot00000000000000val zero : int32 val one : int32 val minus_one : int32 external neg : int32 -> int32 = "%int32_neg" external add : int32 -> int32 -> int32 = "%int32_add" external sub : int32 -> int32 -> int32 = "%int32_sub" external mul : int32 -> int32 -> int32 = "%int32_mul" external div : int32 -> int32 -> int32 = "%int32_div" val unsigned_div : int32 -> int32 -> int32 external rem : int32 -> int32 -> int32 = "%int32_mod" val unsigned_rem : int32 -> int32 -> int32 val succ : int32 -> int32 val pred : int32 -> int32 val abs : int32 -> int32 val max_int : int32 val min_int : int32 external logand : int32 -> int32 -> int32 = "%int32_and" external logor : int32 -> int32 -> int32 = "%int32_or" external logxor : int32 -> int32 -> int32 = "%int32_xor" val lognot : int32 -> int32 external shift_left : int32 -> int -> int32 = "%int32_lsl" external shift_right : int32 -> int -> int32 = "%int32_asr" external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" external of_int : int -> int32 = "%int32_of_int" external to_int : int32 -> int = "%int32_to_int" val unsigned_to_int : int32 -> int option external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_string : string -> int32 = "caml_int32_of_string" val of_string_opt : string -> int32 option val to_string : int32 -> string external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int32 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val seeded_hash : int -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/int64.mli000066400000000000000000000042071463722102200222160ustar00rootroot00000000000000val zero : int64 val one : int64 val minus_one : int64 external neg : int64 -> int64 = "%int64_neg" external add : int64 -> int64 -> int64 = "%int64_add" external sub : int64 -> int64 -> int64 = "%int64_sub" external mul : int64 -> int64 -> int64 = "%int64_mul" external div : int64 -> int64 -> int64 = "%int64_div" val unsigned_div : int64 -> int64 -> int64 external rem : int64 -> int64 -> int64 = "%int64_mod" val unsigned_rem : int64 -> int64 -> int64 val succ : int64 -> int64 val pred : int64 -> int64 val abs : int64 -> int64 val max_int : int64 val min_int : int64 external logand : int64 -> int64 -> int64 = "%int64_and" external logor : int64 -> int64 -> int64 = "%int64_or" external logxor : int64 -> int64 -> int64 = "%int64_xor" val lognot : int64 -> int64 external shift_left : int64 -> int -> int64 = "%int64_lsl" external shift_right : int64 -> int -> int64 = "%int64_asr" external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" external of_int : int -> int64 = "%int64_of_int" external to_int : int64 -> int = "%int64_to_int" val unsigned_to_int : int64 -> int option external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] external of_int32 : int32 -> int64 = "%int64_of_int32" external to_int32 : int64 -> int32 = "%int64_to_int32" external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" external of_string : string -> int64 = "caml_int64_of_string" val of_string_opt : string -> int64 option val to_string : int64 -> string external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] type t = int64 val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val seeded_hash : int -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/lazy.mli000066400000000000000000000004441463722102200222300ustar00rootroot00000000000000type 'a t = 'a CamlinternalLazy.t exception Undefined external force : 'a t -> 'a = "%lazy_force" val map : ('a -> 'b) -> 'a t -> 'b t val is_val : 'a t -> bool val from_val : 'a -> 'a t val map_val : ('a -> 'b) -> 'a t -> 'b t val from_fun : (unit -> 'a) -> 'a t val force_val : 'a t -> 'a ocaml-stdcompat-20~git20240529/interfaces/5.2/lexing.mli000066400000000000000000000032651463722102200225430ustar00rootroot00000000000000type position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } val dummy_pos : position type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } val from_channel : ?with_positions:bool -> in_channel -> lexbuf val from_string : ?with_positions:bool -> string -> lexbuf val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf val set_position : lexbuf -> position -> unit val set_filename : lexbuf -> string -> unit val with_positions : lexbuf -> bool val lexeme : lexbuf -> string val lexeme_char : lexbuf -> int -> char val lexeme_start : lexbuf -> int val lexeme_end : lexbuf -> int val lexeme_start_p : lexbuf -> position val lexeme_end_p : lexbuf -> position val new_line : lexbuf -> unit val flush_input : lexbuf -> unit val sub_lexeme : lexbuf -> int -> int -> string val sub_lexeme_opt : lexbuf -> int -> int -> string option val sub_lexeme_char : lexbuf -> int -> char val sub_lexeme_char_opt : lexbuf -> int -> char option type lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } val engine : lex_tables -> int -> lexbuf -> int val new_engine : lex_tables -> int -> lexbuf -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/list.mli000066400000000000000000000064041463722102200222260ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> int -> int val is_empty : 'a list -> bool val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : int -> (int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : ('a -> unit) -> 'a list -> unit val iteri : (int -> 'a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : ('a -> 'b) -> 'a list -> 'b list val filter_map : ('a -> 'b option) -> 'a list -> 'b list val concat_map : ('a -> 'b list) -> 'a list -> 'b list val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a list -> ('acc * 'b list) val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a list -> 'b list -> 'acc val fold_right2 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'acc val for_all : ('a -> bool) -> 'a list -> bool val exists : ('a -> bool) -> 'a list -> bool val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> 'a list -> bool val memq : 'a -> 'a list -> bool val find : ('a -> bool) -> 'a list -> 'a val find_opt : ('a -> bool) -> 'a list -> 'a option val find_index : ('a -> bool) -> 'a list -> int option val find_map : ('a -> 'b option) -> 'a list -> 'b option val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option val filter : ('a -> bool) -> 'a list -> 'a list val find_all : ('a -> bool) -> 'a list -> 'a list val filteri : (int -> 'a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> ('a * 'b) list -> bool val mem_assq : 'a -> ('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : ('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/5.2/listLabels.mli000066400000000000000000000066141463722102200233540ustar00rootroot00000000000000type 'a t = 'a list = | [] | (::) of 'a * 'a list val length : 'a list -> int val compare_lengths : 'a list -> 'b list -> int val compare_length_with : 'a list -> len:int -> int val is_empty : 'a list -> bool val cons : 'a -> 'a list -> 'a list val hd : 'a list -> 'a val tl : 'a list -> 'a list val nth : 'a list -> int -> 'a val nth_opt : 'a list -> int -> 'a option val rev : 'a list -> 'a list val init : len:int -> f:(int -> 'a) -> 'a list val append : 'a list -> 'a list -> 'a list val rev_append : 'a list -> 'a list -> 'a list val concat : 'a list list -> 'a list val flatten : 'a list list -> 'a list val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int val iter : f:('a -> unit) -> 'a list -> unit val iteri : f:(int -> 'a -> unit) -> 'a list -> unit val map : f:('a -> 'b) -> 'a list -> 'b list val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list val rev_map : f:('a -> 'b) -> 'a list -> 'b list val filter_map : f:('a -> 'b option) -> 'a list -> 'b list val concat_map : f:('a -> 'b list) -> 'a list -> 'b list val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a list -> ('acc * 'b list) val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'acc val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'acc val fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'acc val for_all : f:('a -> bool) -> 'a list -> bool val exists : f:('a -> bool) -> 'a list -> bool val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool val mem : 'a -> set:'a list -> bool val memq : 'a -> set:'a list -> bool val find : f:('a -> bool) -> 'a list -> 'a val find_opt : f:('a -> bool) -> 'a list -> 'a option val find_index : f:('a -> bool) -> 'a list -> int option val find_map : f:('a -> 'b option) -> 'a list -> 'b option val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option val filter : f:('a -> bool) -> 'a list -> 'a list val find_all : f:('a -> bool) -> 'a list -> 'a list val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) val assoc : 'a -> ('a * 'b) list -> 'b val assoc_opt : 'a -> ('a * 'b) list -> 'b option val assq : 'a -> ('a * 'b) list -> 'b val assq_opt : 'a -> ('a * 'b) list -> 'b option val mem_assoc : 'a -> map:('a * 'b) list -> bool val mem_assq : 'a -> map:('a * 'b) list -> bool val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list val split : ('a * 'b) list -> ('a list * 'b list) val combine : 'a list -> 'b list -> ('a * 'b) list val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list val to_seq : 'a list -> 'a Seq.t val of_seq : 'a Seq.t -> 'a list ocaml-stdcompat-20~git20240529/interfaces/5.2/map.mli000066400000000000000000000106361463722102200220320ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +!'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end ocaml-stdcompat-20~git20240529/interfaces/5.2/marshal.mli000066400000000000000000000011031463722102200226710ustar00rootroot00000000000000type extern_flags = | No_sharing | Closures | Compat_32 val to_channel : out_channel -> 'a -> extern_flags list -> unit external to_bytes : 'a -> extern_flags list -> bytes = "caml_output_value_to_bytes" external to_string : 'a -> extern_flags list -> string = "caml_output_value_to_string" val to_buffer : bytes -> int -> int -> 'a -> extern_flags list -> int val from_channel : in_channel -> 'a val from_bytes : bytes -> int -> 'a val from_string : string -> int -> 'a val header_size : int val data_size : bytes -> int -> int val total_size : bytes -> int -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/moreLabels.mli000066400000000000000000000351261463722102200233430ustar00rootroot00000000000000module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'acc -> 'acc) -> ('a, 'b) t -> init:'acc -> 'acc val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t val to_seq_keys : ('a, 'b) t -> 'a Seq.t val to_seq_values : ('a, 'b) t -> 'b Seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key type +!'a t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val add_to_list : key:key -> data:'a -> 'a list t -> 'a list t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val add_to_list : key:key -> data:'a -> 'a list t -> 'a list t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end end module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val map : f:(elt -> elt) -> t -> t val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val map : f:(elt -> elt) -> t -> t val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end end ocaml-stdcompat-20~git20240529/interfaces/5.2/nativeint.mli000066400000000000000000000041301463722102200232460ustar00rootroot00000000000000val zero : nativeint val one : nativeint val minus_one : nativeint external neg : nativeint -> nativeint = "%nativeint_neg" external add : nativeint -> nativeint -> nativeint = "%nativeint_add" external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" external div : nativeint -> nativeint -> nativeint = "%nativeint_div" val unsigned_div : nativeint -> nativeint -> nativeint external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" val unsigned_rem : nativeint -> nativeint -> nativeint val succ : nativeint -> nativeint val pred : nativeint -> nativeint val abs : nativeint -> nativeint val size : int val max_int : nativeint val min_int : nativeint external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" val lognot : nativeint -> nativeint external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" external of_int : int -> nativeint = "%nativeint_of_int" external to_int : nativeint -> int = "%nativeint_to_int" val unsigned_to_int : nativeint -> int option external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] external of_int32 : int32 -> nativeint = "%nativeint_of_int32" external to_int32 : nativeint -> int32 = "%nativeint_to_int32" external of_string : string -> nativeint = "caml_nativeint_of_string" val of_string_opt : string -> nativeint option val to_string : nativeint -> string type t = nativeint val compare : t -> t -> int val unsigned_compare : t -> t -> int val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val seeded_hash : int -> t -> int val hash : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/obj.mli000066400000000000000000000040531463722102200220230ustar00rootroot00000000000000type t type raw_data = nativeint external repr : 'a -> t = "%identity" external obj : t -> 'a = "%identity" external magic : 'a -> 'b = "%identity" val is_block : t -> bool external is_int : t -> bool = "%obj_is_int" external tag : t -> int = "caml_obj_tag"[@@noalloc ] external size : t -> int = "%obj_size" external reachable_words : t -> int = "caml_obj_reachable_words" external field : t -> int -> t = "%obj_field" external set_field : t -> int -> t -> unit = "%obj_set_field" val double_field : t -> int -> float val set_double_field : t -> int -> float -> unit external raw_field : t -> int -> raw_data = "caml_obj_raw_field" external set_raw_field : t -> int -> raw_data -> unit = "caml_obj_set_raw_field" external new_block : int -> int -> t = "caml_obj_block" external dup : t -> t = "caml_obj_dup" external add_offset : t -> Int32.t -> t = "caml_obj_add_offset" external with_tag : int -> t -> t = "caml_obj_with_tag" val first_non_constant_constructor_tag : int val last_non_constant_constructor_tag : int val forcing_tag : int val cont_tag : int val lazy_tag : int val closure_tag : int val object_tag : int val infix_tag : int val forward_tag : int val no_scan_tag : int val abstract_tag : int val string_tag : int val double_tag : int val double_array_tag : int val custom_tag : int val int_tag : int val out_of_heap_tag : int val unaligned_tag : int module Extension_constructor : sig type t = extension_constructor val of_val : 'a -> t val name : t -> string val id : t -> int end module Ephemeron : sig type obj_t = t type t val create : int -> t val length : t -> int val get_key : t -> int -> obj_t option val get_key_copy : t -> int -> obj_t option val set_key : t -> int -> obj_t -> unit val unset_key : t -> int -> unit val check_key : t -> int -> bool val blit_key : t -> int -> t -> int -> int -> unit val get_data : t -> obj_t option val get_data_copy : t -> obj_t option val set_data : t -> obj_t -> unit val unset_data : t -> unit val check_data : t -> bool val blit_data : t -> t -> unit val max_ephe_length : int end ocaml-stdcompat-20~git20240529/interfaces/5.2/oo.mli000066400000000000000000000002571463722102200216700ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag ocaml-stdcompat-20~git20240529/interfaces/5.2/option.mli000066400000000000000000000013331463722102200225570ustar00rootroot00000000000000type 'a t = 'a option = | None | Some of 'a val none : 'a option val some : 'a -> 'a option val value : 'a option -> default:'a -> 'a val get : 'a option -> 'a val bind : 'a option -> ('a -> 'b option) -> 'b option val join : 'a option option -> 'a option val map : ('a -> 'b) -> 'a option -> 'b option val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a val iter : ('a -> unit) -> 'a option -> unit val is_none : 'a option -> bool val is_some : 'a option -> bool val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int val to_result : none:'e -> 'a option -> ('a, 'e) result val to_list : 'a option -> 'a list val to_seq : 'a option -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/5.2/out_channel.mli000066400000000000000000000023021463722102200235430ustar00rootroot00000000000000type t = out_channel type open_flag = open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val stdout : t val stderr : t val open_bin : string -> t val open_text : string -> t val open_gen : open_flag list -> int -> string -> t val with_open_bin : string -> (t -> 'a) -> 'a val with_open_text : string -> (t -> 'a) -> 'a val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a val close : t -> unit val close_noerr : t -> unit val output_char : t -> char -> unit val output_byte : t -> int -> unit val output_string : t -> string -> unit val output_bytes : t -> bytes -> unit val output : t -> bytes -> int -> int -> unit val output_substring : t -> string -> int -> int -> unit val output_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> unit val flush : t -> unit val flush_all : unit -> unit val seek : t -> int64 -> unit val pos : t -> int64 val length : t -> int64 val set_binary_mode : t -> bool -> unit val is_binary_mode : t -> bool val set_buffered : t -> bool -> unit val is_buffered : t -> bool val isatty : t -> bool ocaml-stdcompat-20~git20240529/interfaces/5.2/parsing.mli000066400000000000000000000017421463722102200227160ustar00rootroot00000000000000val symbol_start : unit -> int val symbol_end : unit -> int val rhs_start : int -> int val rhs_end : int -> int val symbol_start_pos : unit -> Lexing.position val symbol_end_pos : unit -> Lexing.position val rhs_start_pos : int -> Lexing.position val rhs_end_pos : int -> Lexing.position val clear_parser : unit -> unit exception Parse_error val set_trace : bool -> bool type parser_env type parse_tables = { actions: (parser_env -> Obj.t) array ; transl_const: int array ; transl_block: int array ; lhs: string ; len: string ; defred: string ; dgoto: string ; sindex: string ; rindex: string ; gindex: string ; tablesize: int ; table: string ; check: string ; error_function: string -> unit ; names_const: string ; names_block: string } exception YYexit of Obj.t val yyparse : parse_tables -> int -> (Lexing.lexbuf -> 'a) -> Lexing.lexbuf -> 'b val peek_val : parser_env -> int -> 'a val is_current_lookahead : 'a -> bool val parse_error : string -> unit ocaml-stdcompat-20~git20240529/interfaces/5.2/printexc.mli000066400000000000000000000036241463722102200231100ustar00rootroot00000000000000type t = exn = .. val to_string : exn -> string val to_string_default : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b val print_backtrace : out_channel -> unit val get_backtrace : unit -> string val record_backtrace : bool -> unit val backtrace_status : unit -> bool val register_printer : (exn -> string option) -> unit val use_printers : exn -> string option type raw_backtrace type raw_backtrace_entry = private int val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array val get_raw_backtrace : unit -> raw_backtrace val print_raw_backtrace : out_channel -> raw_backtrace -> unit val raw_backtrace_to_string : raw_backtrace -> string external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" val default_uncaught_exception_handler : exn -> raw_backtrace -> unit val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit type backtrace_slot val backtrace_slots : raw_backtrace -> backtrace_slot array option val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option type location = { filename: string ; line_number: int ; start_char: int ; end_char: int ; end_line: int ; end_col: int } module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end type raw_backtrace_slot val raw_backtrace_length : raw_backtrace -> int val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option val exn_slot_id : exn -> int val exn_slot_name : exn -> string val string_of_extension_constructor : Obj.t -> string ocaml-stdcompat-20~git20240529/interfaces/5.2/printf.mli000066400000000000000000000015501463722102200225520ustar00rootroot00000000000000val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a val printf : ('a, out_channel, unit) format -> 'a val eprintf : ('a, out_channel, unit) format -> 'a val sprintf : ('a, unit, string) format -> 'a val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a ocaml-stdcompat-20~git20240529/interfaces/5.2/queue.mli000066400000000000000000000011261463722102200223730ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val add : 'a -> 'a t -> unit val push : 'a -> 'a t -> unit val take : 'a t -> 'a val take_opt : 'a t -> 'a option val pop : 'a t -> 'a val peek : 'a t -> 'a val peek_opt : 'a t -> 'a option val top : 'a t -> 'a val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val transfer : 'a t -> 'a t -> unit val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/5.2/random.mli000066400000000000000000000027751463722102200225420ustar00rootroot00000000000000val init : int -> unit val full_init : int array -> unit val self_init : unit -> unit val bits : unit -> int val int : int -> int val full_int : int -> int val int_in_range : min:int -> max:int -> int val int32 : Int32.t -> Int32.t val int32_in_range : min:int32 -> max:int32 -> int32 val nativeint : Nativeint.t -> Nativeint.t val nativeint_in_range : min:nativeint -> max:nativeint -> nativeint val int64 : Int64.t -> Int64.t val int64_in_range : min:int64 -> max:int64 -> int64 val float : float -> float val bool : unit -> bool val bits32 : unit -> Int32.t val bits64 : unit -> Int64.t val nativebits : unit -> Nativeint.t module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val full_int : t -> int -> int val int_in_range : t -> min:int -> max:int -> int val int32 : t -> Int32.t -> Int32.t val int32_in_range : t -> min:int32 -> max:int32 -> int32 val nativeint : t -> Nativeint.t -> Nativeint.t val nativeint_in_range : t -> min:nativeint -> max:nativeint -> nativeint val int64 : t -> Int64.t -> Int64.t val int64_in_range : t -> min:int64 -> max:int64 -> int64 val float : t -> float -> float val bool : t -> bool val bits32 : t -> Int32.t val bits64 : t -> Int64.t val nativebits : t -> Nativeint.t val split : t -> t val to_binary_string : t -> string val of_binary_string : string -> t end val get_state : unit -> State.t val set_state : State.t -> unit val split : unit -> State.t ocaml-stdcompat-20~git20240529/interfaces/5.2/result.mli000066400000000000000000000021341463722102200225650ustar00rootroot00000000000000type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e val ok : 'a -> ('a, 'e) result val error : 'e -> ('a, 'e) result val value : ('a, 'e) result -> default:'a -> 'a val get_ok : ('a, 'e) result -> 'a val get_error : ('a, 'e) result -> 'e val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result val join : (('a, 'e) result, 'e) result -> ('a, 'e) result val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c val iter : ('a -> unit) -> ('a, 'e) result -> unit val iter_error : ('e -> unit) -> ('a, 'e) result -> unit val is_ok : ('a, 'e) result -> bool val is_error : ('a, 'e) result -> bool val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int val to_option : ('a, 'e) result -> 'a option val to_list : ('a, 'e) result -> 'a list val to_seq : ('a, 'e) result -> 'a Seq.t ocaml-stdcompat-20~git20240529/interfaces/5.2/scanf.mli000066400000000000000000000033331463722102200223430ustar00rootroot00000000000000module Scanning : sig type in_channel type scanbuf = in_channel val stdin : in_channel type file_name = string val open_in : file_name -> in_channel val open_in_bin : file_name -> in_channel val close_in : in_channel -> unit val from_file : file_name -> in_channel val from_file_bin : string -> in_channel val from_string : string -> in_channel val from_function : (unit -> char) -> in_channel val from_channel : Stdlib.in_channel -> in_channel val end_of_input : in_channel -> bool val beginning_of_input : in_channel -> bool val name_of_input : in_channel -> string end type ('a, 'b, 'c, 'd) scanner = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c type ('a, 'b, 'c, 'd) scanner_opt = ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd option, 'd) format6 -> 'c exception Scan_failure of string val bscanf : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner val bscanf_opt : Scanning.in_channel -> ('a, 'b, 'c, 'd) scanner_opt val sscanf : string -> ('a, 'b, 'c, 'd) scanner val sscanf_opt : string -> ('a, 'b, 'c, 'd) scanner_opt val scanf : ('a, 'b, 'c, 'd) scanner val scanf_opt : ('a, 'b, 'c, 'd) scanner_opt val kscanf : Scanning.in_channel -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val ksscanf : string -> (Scanning.in_channel -> exn -> 'd) -> ('a, 'b, 'c, 'd) scanner val bscanf_format : Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val sscanf_format : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g val format_from_string : string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 val unescaped : string -> string ocaml-stdcompat-20~git20240529/interfaces/5.2/seq.mli000066400000000000000000000051001463722102200220330ustar00rootroot00000000000000type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t val is_empty : 'a t -> bool val uncons : 'a t -> ('a * 'a t) option val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val iteri : (int -> 'a -> unit) -> 'a t -> unit val fold_lefti : ('acc -> int -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val for_all : ('a -> bool) -> 'a t -> bool val exists : ('a -> bool) -> 'a t -> bool val find : ('a -> bool) -> 'a t -> 'a option val find_index : ('a -> bool) -> 'a t -> int option val find_map : ('a -> 'b option) -> 'a t -> 'b option val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int val empty : 'a t val return : 'a -> 'a t val cons : 'a -> 'a t -> 'a t val init : int -> (int -> 'a) -> 'a t val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t val repeat : 'a -> 'a t val forever : (unit -> 'a) -> 'a t val cycle : 'a t -> 'a t val iterate : ('a -> 'a) -> 'a -> 'a t val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t val filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t val take : int -> 'a t -> 'a t val drop : int -> 'a t -> 'a t val take_while : ('a -> bool) -> 'a t -> 'a t val drop_while : ('a -> bool) -> 'a t -> 'a t val group : ('a -> 'a -> bool) -> 'a t -> 'a t t val memoize : 'a t -> 'a t exception Forced_twice val once : 'a t -> 'a t val transpose : 'a t t -> 'a t t val append : 'a t -> 'a t -> 'a t val concat : 'a t t -> 'a t val flat_map : ('a -> 'b t) -> 'a t -> 'b t val concat_map : ('a -> 'b t) -> 'a t -> 'b t val zip : 'a t -> 'b t -> ('a * 'b) t val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val interleave : 'a t -> 'a t -> 'a t val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t val product : 'a t -> 'b t -> ('a * 'b) t val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t val unzip : ('a * 'b) t -> ('a t * 'b t) val split : ('a * 'b) t -> ('a t * 'b t) val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> ('b t * 'c t) val partition : ('a -> bool) -> 'a t -> ('a t * 'a t) val of_dispenser : (unit -> 'a option) -> 'a t val to_dispenser : 'a t -> unit -> 'a option val ints : int -> int t ocaml-stdcompat-20~git20240529/interfaces/5.2/set.mli000066400000000000000000000064301463722102200220450ustar00rootroot00000000000000module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end ocaml-stdcompat-20~git20240529/interfaces/5.2/stack.mli000066400000000000000000000007771463722102200223670ustar00rootroot00000000000000type !'a t exception Empty val create : unit -> 'a t val push : 'a -> 'a t -> unit val pop : 'a t -> 'a val pop_opt : 'a t -> 'a option val drop : 'a t -> unit val top : 'a t -> 'a val top_opt : 'a t -> 'a option val clear : 'a t -> unit val copy : 'a t -> 'a t val is_empty : 'a t -> bool val length : 'a t -> int val iter : ('a -> unit) -> 'a t -> unit val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val to_seq : 'a t -> 'a Seq.t val add_seq : 'a t -> 'a Seq.t -> unit val of_seq : 'a Seq.t -> 'a t ocaml-stdcompat-20~git20240529/interfaces/5.2/stdLabels.mli000066400000000000000000000001541463722102200231640ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels ocaml-stdcompat-20~git20240529/interfaces/5.2/stdlib.mli000066400000000000000000000277071463722102200225450ustar00rootroot00000000000000external raise : exn -> 'a = "%raise" external raise_notrace : exn -> 'a = "%raise_notrace" val invalid_arg : string -> 'a val failwith : string -> 'a exception Exit exception Match_failure of (string * int * int) exception Assert_failure of (string * int * int) exception Invalid_argument of string exception Failure of string exception Not_found exception Out_of_memory exception Stack_overflow exception Sys_error of string exception End_of_file exception Division_by_zero exception Sys_blocked_io exception Undefined_recursive_module of (string * int * int) external (=) : 'a -> 'a -> bool = "%equal" external (<>) : 'a -> 'a -> bool = "%notequal" external (<) : 'a -> 'a -> bool = "%lessthan" external (>) : 'a -> 'a -> bool = "%greaterthan" external (<=) : 'a -> 'a -> bool = "%lessequal" external (>=) : 'a -> 'a -> bool = "%greaterequal" external compare : 'a -> 'a -> int = "%compare" val min : 'a -> 'a -> 'a val max : 'a -> 'a -> 'a external (==) : 'a -> 'a -> bool = "%eq" external (!=) : 'a -> 'a -> bool = "%noteq" external not : bool -> bool = "%boolnot" external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" external __LOC__ : string = "%loc_LOC" external __FILE__ : string = "%loc_FILE" external __LINE__ : int = "%loc_LINE" external __MODULE__ : string = "%loc_MODULE" external __POS__ : (string * int * int * int) = "%loc_POS" external __FUNCTION__ : string = "%loc_FUNCTION" external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" external (~-) : int -> int = "%negint" external (~+) : int -> int = "%identity" external succ : int -> int = "%succint" external pred : int -> int = "%predint" external (+) : int -> int -> int = "%addint" external (-) : int -> int -> int = "%subint" external ( * ) : int -> int -> int = "%mulint" external (/) : int -> int -> int = "%divint" external \#mod : int -> int -> int = "%modint" val abs : int -> int val max_int : int val min_int : int external \#land : int -> int -> int = "%andint" external \#lor : int -> int -> int = "%orint" external \#lxor : int -> int -> int = "%xorint" val lnot : int -> int external \#lsl : int -> int -> int = "%lslint" external \#lsr : int -> int -> int = "%lsrint" external \#asr : int -> int -> int = "%asrint" external (~-.) : float -> float = "%negfloat" external (~+.) : float -> float = "%identity" external (+.) : float -> float -> float = "%addfloat" external (-.) : float -> float -> float = "%subfloat" external ( *. ) : float -> float -> float = "%mulfloat" external (/.) : float -> float -> float = "%divfloat" external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] external abs_float : float -> float = "%absfloat" external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] external frexp : float -> (float * int) = "caml_frexp_float" external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] external modf : float -> (float * float) = "caml_modf_float" external float : int -> float = "%floatofint" external float_of_int : int -> float = "%floatofint" external truncate : float -> int = "%intoffloat" external int_of_float : float -> int = "%intoffloat" val infinity : float val neg_infinity : float val nan : float val max_float : float val min_float : float val epsilon_float : float type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] val (^) : string -> string -> string external int_of_char : char -> int = "%identity" val char_of_int : int -> char external ignore : 'a -> unit = "%ignore" val string_of_bool : bool -> string val bool_of_string_opt : string -> bool option val bool_of_string : string -> bool val string_of_int : int -> string val int_of_string_opt : string -> int option external int_of_string : string -> int = "caml_int_of_string" val string_of_float : float -> string val float_of_string_opt : string -> float option external float_of_string : string -> float = "caml_float_of_string" external fst : ('a * 'b) -> 'a = "%field0" external snd : ('a * 'b) -> 'b = "%field1" val (@) : 'a list -> 'a list -> 'a list type in_channel type out_channel val stdin : in_channel val stdout : out_channel val stderr : out_channel val print_char : char -> unit val print_string : string -> unit val print_bytes : bytes -> unit val print_int : int -> unit val print_float : float -> unit val print_endline : string -> unit val print_newline : unit -> unit val prerr_char : char -> unit val prerr_string : string -> unit val prerr_bytes : bytes -> unit val prerr_int : int -> unit val prerr_float : float -> unit val prerr_endline : string -> unit val prerr_newline : unit -> unit val read_line : unit -> string val read_int_opt : unit -> int option val read_int : unit -> int val read_float_opt : unit -> float option val read_float : unit -> float type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val flush_all : unit -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> bytes -> unit val output : out_channel -> bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> bytes -> int -> int -> int val really_input : in_channel -> bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end type 'a ref = { mutable contents: 'a } external ref : 'a -> 'a ref = "%makemutable" external (!) : 'a ref -> 'a = "%field0" external (:=) : 'a ref -> 'a -> unit = "%setfield0" external incr : int ref -> unit = "%incr" external decr : int ref -> unit = "%decr" type ('a, 'b) result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val exit : int -> 'a val at_exit : (unit -> unit) -> unit val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit val do_domain_local_at_exit : (unit -> unit) ref module Arg = Arg module Array = Array module ArrayLabels = ArrayLabels module Atomic = Atomic module Bigarray = Bigarray module Bool = Bool module Buffer = Buffer module Bytes = Bytes module BytesLabels = BytesLabels module Callback = Callback module Char = Char module Complex = Complex module Condition = Condition module Digest = Digest module Domain = Domain module Dynarray = Dynarray module Effect = Effect module Either = Either module Ephemeron = Ephemeron module Filename = Filename module Float = Float module Format = Format module Fun = Fun module Gc = Gc module Hashtbl = Hashtbl module In_channel = In_channel module Int = Int module Int32 = Int32 module Int64 = Int64 module Lazy = Lazy module Lexing = Lexing module List = List module ListLabels = ListLabels module Map = Map module Marshal = Marshal module MoreLabels = MoreLabels module Mutex = Mutex module Nativeint = Nativeint module Obj = Obj module Oo = Oo module Option = Option module Out_channel = Out_channel module Parsing = Parsing module Printexc = Printexc module Printf = Printf module Queue = Queue module Random = Random module Result = Result module Scanf = Scanf module Semaphore = Semaphore module Seq = Seq module Set = Set module Stack = Stack module StdLabels = StdLabels module String = String module StringLabels = StringLabels module Sys = Sys module Type = Type module Uchar = Uchar module Unit = Unit module Weak = Weak ocaml-stdcompat-20~git20240529/interfaces/5.2/string.mli000066400000000000000000000057151463722102200225650ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> (int -> char) -> string val empty : string external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val of_bytes : bytes -> string val to_bytes : string -> bytes val blit : string -> int -> bytes -> int -> int -> unit val concat : string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> int -> int -> string val split_on_char : char -> string -> string list val map : (char -> char) -> string -> string val mapi : (int -> char -> char) -> string -> string val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc val for_all : (char -> bool) -> string -> bool val exists : (char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : (char -> unit) -> string -> unit val iteri : (int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val hash : t -> int val seeded_hash : int -> t -> int val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/5.2/stringLabels.mli000066400000000000000000000057631463722102200237130ustar00rootroot00000000000000type t = string val make : int -> char -> string val init : int -> f:(int -> char) -> string val empty : string external length : string -> int = "%string_length" external get : string -> int -> char = "%string_safe_get" val of_bytes : bytes -> string val to_bytes : string -> bytes val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit val concat : sep:string -> string list -> string val cat : string -> string -> string val equal : t -> t -> bool val compare : t -> t -> int val starts_with : prefix:string -> string -> bool val ends_with : suffix:string -> string -> bool val contains_from : string -> int -> char -> bool val rcontains_from : string -> int -> char -> bool val contains : string -> char -> bool val sub : string -> pos:int -> len:int -> string val split_on_char : sep:char -> string -> string list val map : f:(char -> char) -> string -> string val mapi : f:(int -> char -> char) -> string -> string val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> string -> 'acc val fold_right : f:(char -> 'acc -> 'acc) -> string -> init:'acc -> 'acc val for_all : f:(char -> bool) -> string -> bool val exists : f:(char -> bool) -> string -> bool val trim : string -> string val escaped : string -> string val uppercase_ascii : string -> string val lowercase_ascii : string -> string val capitalize_ascii : string -> string val uncapitalize_ascii : string -> string val iter : f:(char -> unit) -> string -> unit val iteri : f:(int -> char -> unit) -> string -> unit val index_from : string -> int -> char -> int val index_from_opt : string -> int -> char -> int option val rindex_from : string -> int -> char -> int val rindex_from_opt : string -> int -> char -> int option val index : string -> char -> int val index_opt : string -> char -> int option val rindex : string -> char -> int val rindex_opt : string -> char -> int option val to_seq : t -> char Seq.t val to_seqi : t -> (int * char) Seq.t val of_seq : char Seq.t -> t val get_utf_8_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_8 : t -> bool val get_utf_16be_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16be : t -> bool val get_utf_16le_uchar : t -> int -> Uchar.utf_decode val is_valid_utf_16le : t -> bool val get_uint8 : string -> int -> int val get_int8 : string -> int -> int val get_uint16_ne : string -> int -> int val get_uint16_be : string -> int -> int val get_uint16_le : string -> int -> int val get_int16_ne : string -> int -> int val get_int16_be : string -> int -> int val get_int16_le : string -> int -> int val get_int32_ne : string -> int -> int32 val hash : t -> int val seeded_hash : int -> t -> int val get_int32_be : string -> int -> int32 val get_int32_le : string -> int -> int32 val get_int64_ne : string -> int -> int64 val get_int64_be : string -> int -> int64 val get_int64_le : string -> int -> int64 external unsafe_get : string -> int -> char = "%string_unsafe_get" external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] ocaml-stdcompat-20~git20240529/interfaces/5.2/sys.mli000066400000000000000000000057471463722102200221020ustar00rootroot00000000000000external argv : string array = "%sys_argv" val executable_name : string external file_exists : string -> bool = "caml_sys_file_exists" external is_directory : string -> bool = "caml_sys_is_directory" external is_regular_file : string -> bool = "caml_sys_is_regular_file" external remove : string -> unit = "caml_sys_remove" external rename : string -> string -> unit = "caml_sys_rename" external getenv : string -> string = "caml_sys_getenv" val getenv_opt : string -> string option external command : string -> int = "caml_sys_system_command" external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] external chdir : string -> unit = "caml_sys_chdir" external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" external getcwd : unit -> string = "caml_sys_getcwd" external readdir : string -> string array = "caml_sys_read_directory" val interactive : bool ref val os_type : string type backend_type = | Native | Bytecode | Other of string val backend_type : backend_type val unix : bool val win32 : bool val cygwin : bool val word_size : int val int_size : int val big_endian : bool val max_string_length : int val max_array_length : int val max_floatarray_length : int external runtime_variant : unit -> string = "caml_runtime_variant" external runtime_parameters : unit -> string = "caml_runtime_parameters" type signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" val set_signal : int -> signal_behavior -> unit val sigabrt : int val sigalrm : int val sigfpe : int val sighup : int val sigill : int val sigint : int val sigkill : int val sigpipe : int val sigquit : int val sigsegv : int val sigterm : int val sigusr1 : int val sigusr2 : int val sigchld : int val sigcont : int val sigstop : int val sigtstp : int val sigttin : int val sigttou : int val sigvtalrm : int val sigprof : int val sigbus : int val sigpoll : int val sigsys : int val sigtrap : int val sigurg : int val sigxcpu : int val sigxfsz : int exception Break val catch_break : bool -> unit val ocaml_version : string val development_version : bool type extra_prefix = | Plus | Tilde type extra_info = (extra_prefix * string) type ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } val ocaml_release : ocaml_release_info val enable_runtime_warnings : bool -> unit val runtime_warnings_enabled : unit -> bool external opaque_identity : 'a -> 'a = "%opaque" module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig type t[@@immediate ] end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig type t[@@immediate64 ] type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr val repr : t repr end end ocaml-stdcompat-20~git20240529/interfaces/5.2/uchar.mli000066400000000000000000000012611463722102200223510ustar00rootroot00000000000000type t[@@immediate ] val min : t val max : t val bom : t val rep : t val succ : t -> t val pred : t -> t val is_valid : int -> bool val of_int : int -> t val unsafe_of_int : int -> t val to_int : t -> int val is_char : t -> bool val of_char : char -> t val to_char : t -> char val unsafe_to_char : t -> char val equal : t -> t -> bool val compare : t -> t -> int val hash : t -> int type utf_decode[@@immediate ] val utf_decode_is_valid : utf_decode -> bool val utf_decode_uchar : utf_decode -> t val utf_decode_length : utf_decode -> int val utf_decode : int -> t -> utf_decode val utf_decode_invalid : int -> utf_decode val utf_8_byte_length : t -> int val utf_16_byte_length : t -> int ocaml-stdcompat-20~git20240529/interfaces/5.2/unit.mli000066400000000000000000000001531463722102200222250ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string ocaml-stdcompat-20~git20240529/interfaces/5.2/weak.mli000066400000000000000000000026361463722102200222050ustar00rootroot00000000000000type !'a t val create : int -> 'a t val length : 'a t -> int val set : 'a t -> int -> 'a option -> unit val get : 'a t -> int -> 'a option val get_copy : 'a t -> int -> 'a option val check : 'a t -> int -> bool val fill : 'a t -> int -> int -> 'a option -> unit val blit : 'a t -> int -> 'a t -> int -> int -> unit module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end ocaml-stdcompat-20~git20240529/missing000077500000000000000000000153361463722102200175240ustar00rootroot00000000000000#! /bin/sh # Common wrapper for a few potentially missing GNU programs. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1996-2021 Free Software Foundation, Inc. # Originally written by Fran,cois Pinard , 1996. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. if test $# -eq 0; then echo 1>&2 "Try '$0 --help' for more information" exit 1 fi case $1 in --is-lightweight) # Used by our autoconf macros to check whether the available missing # script is modern enough. exit 0 ;; --run) # Back-compat with the calling convention used by older automake. shift ;; -h|--h|--he|--hel|--help) echo "\ $0 [OPTION]... PROGRAM [ARGUMENT]... Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due to PROGRAM being missing or too old. Options: -h, --help display this help and exit -v, --version output version information and exit Supported PROGRAM values: aclocal autoconf autoheader autom4te automake makeinfo bison yacc flex lex help2man Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and 'g' are ignored when checking the name. Send bug reports to ." exit $? ;; -v|--v|--ve|--ver|--vers|--versi|--versio|--version) echo "missing $scriptversion (GNU Automake)" exit $? ;; -*) echo 1>&2 "$0: unknown '$1' option" echo 1>&2 "Try '$0 --help' for more information" exit 1 ;; esac # Run the given program, remember its exit status. "$@"; st=$? # If it succeeded, we are done. test $st -eq 0 && exit 0 # Also exit now if we it failed (or wasn't found), and '--version' was # passed; such an option is passed most likely to detect whether the # program is present and works. case $2 in --version|--help) exit $st;; esac # Exit code 63 means version mismatch. This often happens when the user # tries to use an ancient version of a tool on a file that requires a # minimum version. if test $st -eq 63; then msg="probably too old" elif test $st -eq 127; then # Program was missing. msg="missing on your system" else # Program was found and executed, but failed. Give up. exit $st fi perl_URL=https://www.perl.org/ flex_URL=https://github.com/westes/flex gnu_software_URL=https://www.gnu.org/software program_details () { case $1 in aclocal|automake) echo "The '$1' program is part of the GNU Automake package:" echo "<$gnu_software_URL/automake>" echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:" echo "<$gnu_software_URL/autoconf>" echo "<$gnu_software_URL/m4/>" echo "<$perl_URL>" ;; autoconf|autom4te|autoheader) echo "The '$1' program is part of the GNU Autoconf package:" echo "<$gnu_software_URL/autoconf/>" echo "It also requires GNU m4 and Perl in order to run:" echo "<$gnu_software_URL/m4/>" echo "<$perl_URL>" ;; esac } give_advice () { # Normalize program name to check for. normalized_program=`echo "$1" | sed ' s/^gnu-//; t s/^gnu//; t s/^g//; t'` printf '%s\n' "'$1' is $msg." configure_deps="'configure.ac' or m4 files included by 'configure.ac'" case $normalized_program in autoconf*) echo "You should only need it if you modified 'configure.ac'," echo "or m4 files included by it." program_details 'autoconf' ;; autoheader*) echo "You should only need it if you modified 'acconfig.h' or" echo "$configure_deps." program_details 'autoheader' ;; automake*) echo "You should only need it if you modified 'Makefile.am' or" echo "$configure_deps." program_details 'automake' ;; aclocal*) echo "You should only need it if you modified 'acinclude.m4' or" echo "$configure_deps." program_details 'aclocal' ;; autom4te*) echo "You might have modified some maintainer files that require" echo "the 'autom4te' program to be rebuilt." program_details 'autom4te' ;; bison*|yacc*) echo "You should only need it if you modified a '.y' file." echo "You may want to install the GNU Bison package:" echo "<$gnu_software_URL/bison/>" ;; lex*|flex*) echo "You should only need it if you modified a '.l' file." echo "You may want to install the Fast Lexical Analyzer package:" echo "<$flex_URL>" ;; help2man*) echo "You should only need it if you modified a dependency" \ "of a man page." echo "You may want to install the GNU Help2man package:" echo "<$gnu_software_URL/help2man/>" ;; makeinfo*) echo "You should only need it if you modified a '.texi' file, or" echo "any other file indirectly affecting the aspect of the manual." echo "You might want to install the Texinfo package:" echo "<$gnu_software_URL/texinfo/>" echo "The spurious makeinfo call might also be the consequence of" echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might" echo "want to install GNU make:" echo "<$gnu_software_URL/make/>" ;; *) echo "You might have modified some files without having the proper" echo "tools for further handling them. Check the 'README' file, it" echo "often tells you about the needed prerequisites for installing" echo "this package. You may also peek at any GNU archive site, in" echo "case some other package contains this missing '$1' program." ;; esac } give_advice "$1" | sed -e '1s/^/WARNING: /' \ -e '2,$s/^/ /' >&2 # Propagate the correct exit status (expected to be 127 for a program # not found, 63 for a program that failed due to version mismatch). exit $st # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: ocaml-stdcompat-20~git20240529/stdcompat.h.in000066400000000000000000000002111463722102200206630ustar00rootroot00000000000000@C_BEGIN_BEFORE_4_06_0@ #include value caml_alloc_initialized_string(mlsize_t len, const char *p); @C_END_BEFORE_4_06_0@ ocaml-stdcompat-20~git20240529/stdcompat.ml.in000066400000000000000000000001261463722102200210510ustar00rootroot00000000000000include Stdcompat__root module Stdlib = Stdcompat__stdlib include Stdcompat__stdlib ocaml-stdcompat-20~git20240529/stdcompat.mli.in000066400000000000000000000003561463722102200212270ustar00rootroot00000000000000type bytes = Stdcompat__init.bytes (** @before 4.02.0 alias to [string]. *) type floatarray = Stdcompat__init.floatarray (** @before 4.06.0 alias to [float array]. *) module Stdlib : Stdcompat__stdlib_s.S include Stdcompat__stdlib_s.S ocaml-stdcompat-20~git20240529/stdcompat.opam000066400000000000000000000015271463722102200207760ustar00rootroot00000000000000opam-version: "2.0" synopsis: "Compatibility module for OCaml standard library" description: "Compatibility module for OCaml standard library allowing programs to use some recent additions to the OCaml standard library while preserving the ability to be compiled on former versions of OCaml." maintainer: "Thierry Martinez " authors: "Thierry Martinez " license: "BSD-2-Clause" homepage: "https://github.com/thierry-martinez/stdcompat" bug-reports: "https://github.com/thierry-martinez/stdcompat/issues" depends: [ "ocaml" {>= "3.07"} "dune" {>= "2.0"} ] depopts: [ "result" "seq" "uchar" "ocamlfind" ] build: [ ["dune" "subst"] {dev} ["dune" "build" "-p" name "-j" jobs] ["dune" "runtest" "-p" name "-j" jobs] {with-test} ] dev-repo: "git+https://github.com/thierry-martinez/stdcompat.git" version: "19" ocaml-stdcompat-20~git20240529/stdcompat__arg.ml.in000066400000000000000000000101611463722102200220410ustar00rootroot00000000000000@BEGIN_FROM_4_12_0@ include Arg @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ exception Help of string exception Bad of string let not_implemented () = failwith "Stdcompat.Arg is not fully implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) type key = string type doc = string type usage_msg = string type anon_fun = string -> unit let rec no_expand spec = match spec with | Unit f -> Arg.Unit f | Bool f -> Arg.Bool f | Set r -> Arg.Set r | Clear c -> Arg.Clear c | String f -> Arg.String f | Set_string r -> Arg.Set_string r | Int f -> Arg.Int f | Set_int r -> Arg.Set_int r | Float f -> Arg.Float f | Set_float r -> Arg.Set_float r | Tuple l -> Arg.Tuple (List.map no_expand l) | Symbol (l, f) -> Arg.Symbol (l, f) | Rest f -> Arg.Rest f | Rest_all _ -> not_implemented () @BEGIN_FROM_4_05_0@ | Expand f -> Expand f @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ | Expand _ -> not_implemented () @END_BEFORE_4_05_0@ let rec expand spec = match spec with | Arg.Unit f -> Unit f | Arg.Bool f -> Bool f | Arg.Set r -> Set r | Arg.Clear c -> Clear c | Arg.String f -> String f | Arg.Set_string r -> Set_string r | Arg.Int f -> Int f | Arg.Set_int r -> Set_int r | Arg.Float f -> Float f | Arg.Set_float r -> Set_float r | Arg.Tuple l -> Tuple (List.map expand l) | Arg.Symbol (l, f) -> Symbol (l, f) | Arg.Rest f -> Rest f @BEGIN_FROM_4_05_0@ | Arg.Expand f -> Expand f @END_FROM_4_05_0@ @BEGIN_FROM_4_12_0@ | Arg.Rest_all f -> Rest_all f @END_FROM_4_12_0@ let no_expand_list l = List.map (fun (k, s, d) -> k, no_expand s, d) l let expand_list l = List.map (fun (k, s, d) -> k, expand s, d) l @BEGIN_FROM_3_12_0@ let usage_string l msg = Arg.usage_string (no_expand_list l) msg @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ let usage_string l msg = not_implemented () @END_BEFORE_3_12_0@ @BEGIN_FROM_3_08_0@ let align ?limit:_limit l = expand_list (Arg.align (no_expand_list l)) @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ let align ?limit:_limit _l = not_implemented () @END_BEFORE_3_08_0@ let parse l anon msg = Arg.parse (no_expand_list l) anon msg let parse_argv ?current argv l anon msg = Arg.parse_argv ?current argv (no_expand_list l) anon msg let usage l msg = Arg.usage (no_expand_list l) msg let current = Arg.current let read_aux trim sep file = let channel = open_in_bin file in try let buffer = Buffer.create 20 in let accu = ref [] in let push () = let s = Buffer.contents buffer in let s = if trim && s <> "" && s.[String.length s - 1] = '\r' then String.sub s 0 (String.length s - 1) else s in accu := s :: !accu in try while true do let c = input_char channel in if c = sep then begin push (); Buffer.clear buffer end else Buffer.add_char buffer c done; assert false with End_of_file -> if Buffer.length buffer > 0 then push (); close_in channel; Array.of_list (List.rev !accu) with e -> close_in_noerr channel; raise e let read_arg = read_aux true '\n' let read_arg0 = read_aux false '\x00' let write_aux sep file args = let channel = open_out_bin file in try Array.iter (fun s -> Printf.fprintf channel "%s%c" s sep) args with e -> close_out_noerr channel; raise e let write_arg = write_aux '\n' let write_arg0 = write_aux '\x00' let parse_argv_dynamic ?current:_current _ = not_implemented () let parse_dynamic _ = not_implemented () let parse_expand _ = not_implemented () let parse_and_expand_argv_dynamic _ = not_implemented () @END_BEFORE_4_12_0@ ocaml-stdcompat-20~git20240529/stdcompat__arg.mli.in000066400000000000000000000000331463722102200222070ustar00rootroot00000000000000include Stdcompat__arg_s.S ocaml-stdcompat-20~git20240529/stdcompat__arg_s.mli.in000066400000000000000000000107101463722102200225340ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_12_0@ type spec = Arg.spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) @END_BEFORE_4_12_0@ (** @since 4.12.0: type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | Rest_all of (string list -> unit) | Expand of (string -> string array) *) @BEGIN_FROM_3_08_0@ type key = string @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ type key = string @END_BEFORE_3_08_0@ (** @since 3.08.0: type key = string *) @BEGIN_FROM_3_08_0@ type doc = string @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ type doc = string @END_BEFORE_3_08_0@ (** @since 3.08.0: type doc = string *) @BEGIN_FROM_3_08_0@ type usage_msg = string @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ type usage_msg = string @END_BEFORE_3_08_0@ (** @since 3.08.0: type usage_msg = string *) @BEGIN_FROM_3_08_0@ type anon_fun = string -> unit @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ type anon_fun = string -> unit @END_BEFORE_3_08_0@ (** @since 3.08.0: type anon_fun = string -> unit *) exception Help of string (** Alias for {!Arg.Help} *) exception Bad of string (** Alias for {!Arg.Bad} *) val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit (** @since 4.05.0: val parse_and_expand_argv_dynamic : int ref -> string array ref -> (key * spec * doc) list ref -> anon_fun -> string -> unit *) val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit (** @since 4.05.0: val parse_expand : (key * spec * doc) list -> anon_fun -> usage_msg -> unit *) val read_arg : string -> string array (** @since 4.05.0: val read_arg : string -> string array *) val read_arg0 : string -> string array (** @since 4.05.0: val read_arg0 : string -> string array *) val write_arg : string -> string array -> unit (** @since 4.05.0: val write_arg : string -> string array -> unit *) val write_arg0 : string -> string array -> unit (** @since 4.05.0: val write_arg0 : string -> string array -> unit *) val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit (** @since 4.02.0: val parse_dynamic : (key * spec * doc) list ref -> anon_fun -> usage_msg -> unit *) val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit (** @since 4.02.0: val parse_argv_dynamic : ?current:int ref -> string array -> (key * spec * doc) list ref -> anon_fun -> string -> unit *) val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list (** @since 4.02.0: val align : ?limit:int -> (key * spec * doc) list -> (key * spec * doc) list *) val usage_string : (key * spec * doc) list -> usage_msg -> string (** @since 3.12.0: val usage_string : (key * spec * doc) list -> usage_msg -> string *) val parse : (key * spec * doc) list -> anon_fun -> usage_msg -> unit (** Alias for {!Arg.parse} *) val parse_argv : ?current:int ref -> string array -> (key * spec * doc) list -> anon_fun -> usage_msg -> unit (** Alias for {!Arg.parse_argv} *) val usage : (key * spec * doc) list -> usage_msg -> unit (** Alias for {!Arg.usage} *) val current : int ref (** Alias for {!Arg.current} *) end ocaml-stdcompat-20~git20240529/stdcompat__array.ml.in000066400000000000000000000125041463722102200224110ustar00rootroot00000000000000include Array @BEGIN_BEFORE_5_2_0@ let init_matrix m n f = init m (fun i -> init n (fun j -> f i j)) let shuffle ~rand array = for i = length array - 1 downto 0 do let j = rand (i + 1) in let tmp = unsafe_get array i in unsafe_set array i array.(j); unsafe_set array j tmp done @END_BEFORE_5_2_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a array @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_02_0@ let create_float l = Array.make l 0. let make_float = create_float @END_BEFORE_4_02_0@ @BEGIN_FROM_4_02_0@ @BEGIN_BEFORE_4_03_0@ let create_float = Array.make_float @END_BEFORE_4_03_0@ @END_FROM_4_02_0@ @BEGIN_BEFORE_4_13_0@ let fold_left_map f init array = let r = ref init in let array' = Array.map (fun item -> let (accu, item') = f !r item in r := accu; item') array in !r, array' let rec find_opt_rec f array i = if i >= length array then None else let item = unsafe_get array i in if f item then Some item else find_opt_rec f array (succ i) let find_opt f array = find_opt_rec f array 0 let rec find_map_rec f array i = if i >= length array then None else match f (unsafe_get array i) with | None -> find_map_rec f array (succ i) | Some _ as result -> result let find_map f array = find_map_rec f array 0 let split array = let l = length array in if l = 0 then ([| |], [| |]) else let (fst0, snd0) = unsafe_get array 0 in let array_fst = Array.make l fst0 in let array_snd = Array.make l snd0 in for i = 1 to l - 1 do let (fsti, sndi) = unsafe_get array i in Array.unsafe_set array_fst i fsti; Array.unsafe_set array_snd i sndi; done; (array_fst, array_snd) let combine array_fst array_snd = if length array_fst <> length array_snd then invalid_arg "Array.combine"; Array.init (length array_fst) (fun i -> (unsafe_get array_fst i, unsafe_get array_snd i)) @END_BEFORE_4_13_0@ @BEGIN_BEFORE_4_11_0@ exception Iter let for_all2 f array1 array2 = if length array1 <> length array2 then invalid_arg "Array.for_all2"; try for i = 0 to length array1 - 1 do if not (f (unsafe_get array1 i) (unsafe_get array2 i)) then raise Iter done; true with Iter -> false let exists2 f array1 array2 = if length array1 <> length array2 then invalid_arg "Array.exists2"; try for i = 0 to length array1 - 1 do if f (unsafe_get array1 i) (unsafe_get array2 i) then raise Iter done; false with Iter -> true @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_03_0@ let iter2 f array1 array2 = if length array1 <> length array2 then invalid_arg "Array.iter2"; for i = 0 to length array1 - 1 do f (unsafe_get array1 i) (unsafe_get array2 i) done let map2 f array1 array2 = if length array1 <> length array2 then invalid_arg "Array.map2"; init (length array1) (fun i -> f (unsafe_get array1 i) (unsafe_get array2 i)) let for_all f array = try for i = 0 to length array - 1 do if not (f (unsafe_get array i)) then raise Iter done; true with Iter -> false let exists f array = try for i = 0 to length array - 1 do if f (unsafe_get array i) then raise Iter done; false with Iter -> true let mem item = exists (( = ) item) let memq item = exists (( == ) item) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_06_0@ module Floatarray = struct let create = create_float let length : Stdcompat__root.floatarray -> int = length let get : Stdcompat__root.floatarray -> int -> float = get let set : Stdcompat__root.floatarray -> int -> float -> unit = set let unsafe_get : Stdcompat__root.floatarray -> int -> float = unsafe_get let unsafe_set : Stdcompat__root.floatarray -> int -> float -> unit = unsafe_set end @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_07_0@ let to_seq s = Stdcompat__tools.vec_to_seq length unsafe_get s let to_seqi s = Stdcompat__tools.vec_to_seqi length unsafe_get s @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_07_1@ (* Array.of_seq is redefined in OCaml 4.07.0 to circumvent a bug in the implementation of the standard library. See: - https://caml.inria.fr/mantis/view.php?id=7820 - https://github.com/ocaml/ocaml/pull/1897 *) let of_rev_list l = match l with | [] -> [||] | hd :: tl -> let len = List.length l in let result = make len hd in let rec fill i l = match l with | [] -> result | hd :: tl -> unsafe_set result i hd; fill (pred i) tl in fill (len - 2) tl let of_seq g = of_rev_list (Stdcompat__seq.fold_left (fun accu x -> x :: accu) [] g) @END_BEFORE_4_07_1@ @BEGIN_BEFORE_5_1_0@ let map_inplace f array = for i = 0 to length array - 1 do unsafe_set array i (f (unsafe_get array i)) done let mapi_inplace f array = for i = 0 to length array - 1 do unsafe_set array i (f i (unsafe_get array i)) done let rec find_index_from index p array = if index < length array then if p (unsafe_get array index) then Some index else find_index_from (succ index) p array else None let find_index p array = find_index_from 0 p array let rec find_mapi_from index f array = if index < length array then match f index (unsafe_get array index) with | None -> find_mapi_from (succ index) f array | some -> some else None let find_mapi f array = find_mapi_from 0 f array @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__array.mli.in000066400000000000000000000000351463722102200225560ustar00rootroot00000000000000include Stdcompat__array_s.S ocaml-stdcompat-20~git20240529/stdcompat__arrayLabels.ml.in000066400000000000000000000004231463722102200235310ustar00rootroot00000000000000@BEGIN_FROM_4_06_0@ include (Stdcompat__array : module type of struct include Stdcompat__array end with module Floatarray := Array.Floatarray) module Floatarray = ArrayLabels.Floatarray @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ include Stdcompat__array @END_BEFORE_4_06_0@ ocaml-stdcompat-20~git20240529/stdcompat__arrayLabels.mli.in000066400000000000000000000000431463722102200237000ustar00rootroot00000000000000include Stdcompat__arrayLabels_s.S ocaml-stdcompat-20~git20240529/stdcompat__arrayLabels_s.mli.in000066400000000000000000000201521463722102200242250ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type 'a t = 'a array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a array @END_BEFORE_4_08_0@ (** @since 4.08.0: type 'a t = 'a array *) @BEGIN_FROM_4_06_0@ module Floatarray = ArrayLabels.Floatarray @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ module Floatarray : sig val create : int -> Stdcompat__init.floatarray val length : Stdcompat__init.floatarray -> int val get : Stdcompat__init.floatarray -> int -> float val set : Stdcompat__init.floatarray -> int -> float -> unit val unsafe_get : Stdcompat__init.floatarray -> int -> float val unsafe_set : Stdcompat__init.floatarray -> int -> float -> unit end @END_BEFORE_4_06_0@ (** @since 4.06.0: module Floatarray = ArrayLabels.Floatarray *) val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> 'a) -> 'a array array (** @since 5.2.0: val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> 'a) -> 'a array array *) val shuffle : rand:(int -> int) -> 'a array -> unit (** @since 5.2.0: val shuffle : rand:(int -> int) -> 'a array -> unit *) val map_inplace : f:('a -> 'a) -> 'a array -> unit (** @since 5.1.0: val map_inplace : f:('a -> 'a) -> 'a array -> unit *) val mapi_inplace : f:(int -> 'a -> 'a) -> 'a array -> unit (** @since 5.1.0: val mapi_inplace : f:(int -> 'a -> 'a) -> 'a array -> unit *) val find_index : f:('a -> bool) -> 'a array -> int option (** @since 5.1.0: val find_index : f:('a -> bool) -> 'a array -> int option *) val find_mapi : f:(int -> 'a -> 'b option) -> 'a array -> 'b option (** @since 5.1.0: val find_mapi : f:(int -> 'a -> 'b option) -> 'a array -> 'b option *) @BEGIN_FROM_5_1_0@ val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a array -> ('acc * 'b array) @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b array -> ('a * 'c array) @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a array -> ('acc * 'b array) @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a array -> ('acc * 'b array) @since 4.13.0: val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b array -> ('a * 'c array) *) val find_opt : f:('a -> bool) -> 'a array -> 'a option (** @since 4.13.0: val find_opt : f:('a -> bool) -> 'a array -> 'a option *) val find_map : f:('a -> 'b option) -> 'a array -> 'b option (** @since 4.13.0: val find_map : f:('a -> 'b option) -> 'a array -> 'b option *) val split : ('a * 'b) array -> ('a array * 'b array) (** @since 4.13.0: val split : ('a * 'b) array -> ('a array * 'b array) *) val combine : 'a array -> 'b array -> ('a * 'b) array (** @since 4.13.0: val combine : 'a array -> 'b array -> ('a * 'b) array *) val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool (** @since 4.11.0: val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool *) val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool (** @since 4.11.0: val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool *) @BEGIN_FROM_4_07_0@ val to_seq : 'a array -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a array -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : 'a array -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : 'a array -> (int * 'a) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : 'a array -> (int * 'a) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : 'a array -> (int * 'a) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a array @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a array @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : 'a Seq.t -> 'a array *) val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit (** @since 4.05.0: val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit *) val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array (** @since 4.05.0: val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array *) @BEGIN_FROM_4_03_0@ external create_float : int -> float array = "caml_make_float_vect" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val create_float : int -> float array @END_BEFORE_4_03_0@ (** @since 4.03.0: external create_float : int -> float array = "caml_make_float_vect" *) val for_all : f:('a -> bool) -> 'a array -> bool (** @since 4.03.0: val for_all : f:('a -> bool) -> 'a array -> bool *) val exists : f:('a -> bool) -> 'a array -> bool (** @since 4.03.0: val exists : f:('a -> bool) -> 'a array -> bool *) val mem : 'a -> set:'a array -> bool (** @since 4.03.0: val mem : 'a -> set:'a array -> bool *) val memq : 'a -> set:'a array -> bool (** @since 4.03.0: val memq : 'a -> set:'a array -> bool *) external length : 'a array -> int = "%array_length" (** Alias for {!ArrayLabels.length} *) external get : 'a array -> int -> 'a = "%array_safe_get" (** Alias for {!ArrayLabels.get} *) external set : 'a array -> int -> 'a -> unit = "%array_safe_set" (** Alias for {!ArrayLabels.set} *) @BEGIN_FROM_3_08_0@ external make : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external make : int -> 'a -> 'a array = "make_vect" @END_BEFORE_3_08_0@ (** @since 3.08.0: external make : int -> 'a -> 'a array = "caml_make_vect" @since 3.07.0: external make : int -> 'a -> 'a array = "make_vect" *) val init : int -> f:(int -> 'a) -> 'a array (** Alias for {!ArrayLabels.init} *) val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array (** Alias for {!ArrayLabels.make_matrix} *) val append : 'a array -> 'a array -> 'a array (** Alias for {!ArrayLabels.append} *) val concat : 'a array list -> 'a array (** Alias for {!ArrayLabels.concat} *) val sub : 'a array -> pos:int -> len:int -> 'a array (** Alias for {!ArrayLabels.sub} *) val copy : 'a array -> 'a array (** Alias for {!ArrayLabels.copy} *) val fill : 'a array -> pos:int -> len:int -> 'a -> unit (** Alias for {!ArrayLabels.fill} *) val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit (** Alias for {!ArrayLabels.blit} *) val to_list : 'a array -> 'a list (** Alias for {!ArrayLabels.to_list} *) val of_list : 'a list -> 'a array (** Alias for {!ArrayLabels.of_list} *) val iter : f:('a -> unit) -> 'a array -> unit (** Alias for {!ArrayLabels.iter} *) val iteri : f:(int -> 'a -> unit) -> 'a array -> unit (** Alias for {!ArrayLabels.iteri} *) val map : f:('a -> 'b) -> 'a array -> 'b array (** Alias for {!ArrayLabels.map} *) val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array (** Alias for {!ArrayLabels.mapi} *) @BEGIN_FROM_5_1_0@ val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc @since 3.07.0: val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : f:('a -> 'acc -> 'acc) -> 'a array -> init:'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_00_0@ val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b @END_BEFORE_4_00_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : f:('a -> 'acc -> 'acc) -> 'a array -> init:'acc -> 'acc @since 4.00.0: val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a @since 3.07.0: val fold_right : f:('a -> 'b -> 'b) -> 'a array -> init:'b -> 'b *) val sort : cmp:('a -> 'a -> int) -> 'a array -> unit (** Alias for {!ArrayLabels.sort} *) val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit (** Alias for {!ArrayLabels.stable_sort} *) val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit (** Alias for {!ArrayLabels.fast_sort} *) external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" (** Alias for {!ArrayLabels.unsafe_get} *) external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" (** Alias for {!ArrayLabels.unsafe_set} *) end ocaml-stdcompat-20~git20240529/stdcompat__array_s.mli.in000066400000000000000000000172631463722102200231130ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type 'a t = 'a array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a array @END_BEFORE_4_08_0@ (** @since 4.08.0: type 'a t = 'a array *) @BEGIN_FROM_4_06_0@ module Floatarray = Array.Floatarray @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ module Floatarray : sig val create : int -> Stdcompat__init.floatarray val length : Stdcompat__init.floatarray -> int val get : Stdcompat__init.floatarray -> int -> float val set : Stdcompat__init.floatarray -> int -> float -> unit val unsafe_get : Stdcompat__init.floatarray -> int -> float val unsafe_set : Stdcompat__init.floatarray -> int -> float -> unit end @END_BEFORE_4_06_0@ (** @since 4.06.0: module Floatarray = Array.Floatarray *) val init_matrix : int -> int -> (int -> int -> 'a) -> 'a array array (** @since 5.2.0: val init_matrix : int -> int -> (int -> int -> 'a) -> 'a array array *) val shuffle : rand:(int -> int) -> 'a array -> unit (** @since 5.2.0: val shuffle : rand:(int -> int) -> 'a array -> unit *) val map_inplace : ('a -> 'a) -> 'a array -> unit (** @since 5.1.0: val map_inplace : ('a -> 'a) -> 'a array -> unit *) val mapi_inplace : (int -> 'a -> 'a) -> 'a array -> unit (** @since 5.1.0: val mapi_inplace : (int -> 'a -> 'a) -> 'a array -> unit *) val find_index : ('a -> bool) -> 'a array -> int option (** @since 5.1.0: val find_index : ('a -> bool) -> 'a array -> int option *) val find_mapi : (int -> 'a -> 'b option) -> 'a array -> 'b option (** @since 5.1.0: val find_mapi : (int -> 'a -> 'b option) -> 'a array -> 'b option *) @BEGIN_FROM_5_1_0@ val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a array -> ('acc * 'b array) @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b array -> ('a * 'c array) @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a array -> ('acc * 'b array) @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a array -> ('acc * 'b array) @since 4.13.0: val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b array -> ('a * 'c array) *) val find_opt : ('a -> bool) -> 'a array -> 'a option (** @since 4.13.0: val find_opt : ('a -> bool) -> 'a array -> 'a option *) val find_map : ('a -> 'b option) -> 'a array -> 'b option (** @since 4.13.0: val find_map : ('a -> 'b option) -> 'a array -> 'b option *) val split : ('a * 'b) array -> ('a array * 'b array) (** @since 4.13.0: val split : ('a * 'b) array -> ('a array * 'b array) *) val combine : 'a array -> 'b array -> ('a * 'b) array (** @since 4.13.0: val combine : 'a array -> 'b array -> ('a * 'b) array *) val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool (** @since 4.11.0: val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool *) val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool (** @since 4.11.0: val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool *) @BEGIN_FROM_4_07_0@ val to_seq : 'a array -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a array -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : 'a array -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : 'a array -> (int * 'a) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : 'a array -> (int * 'a) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : 'a array -> (int * 'a) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a array @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a array @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : 'a Seq.t -> 'a array *) @BEGIN_FROM_4_03_0@ external create_float : int -> float array = "caml_make_float_vect" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val create_float : int -> float array @END_BEFORE_4_03_0@ (** @since 4.03.0: external create_float : int -> float array = "caml_make_float_vect" *) val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit (** @since 4.03.0: val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit *) val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array (** @since 4.03.0: val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array *) val for_all : ('a -> bool) -> 'a array -> bool (** @since 4.03.0: val for_all : ('a -> bool) -> 'a array -> bool *) val exists : ('a -> bool) -> 'a array -> bool (** @since 4.03.0: val exists : ('a -> bool) -> 'a array -> bool *) val mem : 'a -> 'a array -> bool (** @since 4.03.0: val mem : 'a -> 'a array -> bool *) val memq : 'a -> 'a array -> bool (** @since 4.03.0: val memq : 'a -> 'a array -> bool *) external length : 'a array -> int = "%array_length" (** Alias for {!Array.length} *) external get : 'a array -> int -> 'a = "%array_safe_get" (** Alias for {!Array.get} *) external set : 'a array -> int -> 'a -> unit = "%array_safe_set" (** Alias for {!Array.set} *) @BEGIN_FROM_3_08_0@ external make : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external make : int -> 'a -> 'a array = "make_vect" @END_BEFORE_3_08_0@ (** @since 3.08.0: external make : int -> 'a -> 'a array = "caml_make_vect" @since 3.07.0: external make : int -> 'a -> 'a array = "make_vect" *) val init : int -> (int -> 'a) -> 'a array (** Alias for {!Array.init} *) val make_matrix : int -> int -> 'a -> 'a array array (** Alias for {!Array.make_matrix} *) val append : 'a array -> 'a array -> 'a array (** Alias for {!Array.append} *) val concat : 'a array list -> 'a array (** Alias for {!Array.concat} *) val sub : 'a array -> int -> int -> 'a array (** Alias for {!Array.sub} *) val copy : 'a array -> 'a array (** Alias for {!Array.copy} *) val fill : 'a array -> int -> int -> 'a -> unit (** Alias for {!Array.fill} *) val blit : 'a array -> int -> 'a array -> int -> int -> unit (** Alias for {!Array.blit} *) val to_list : 'a array -> 'a list (** Alias for {!Array.to_list} *) val of_list : 'a list -> 'a array (** Alias for {!Array.of_list} *) val iter : ('a -> unit) -> 'a array -> unit (** Alias for {!Array.iter} *) val iteri : (int -> 'a -> unit) -> 'a array -> unit (** Alias for {!Array.iteri} *) val map : ('a -> 'b) -> 'a array -> 'b array (** Alias for {!Array.map} *) val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array (** Alias for {!Array.mapi} *) @BEGIN_FROM_5_1_0@ val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a array -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a array -> 'acc @since 3.07.0: val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : ('a -> 'acc -> 'acc) -> 'a array -> 'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_00_0@ val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b @END_BEFORE_4_00_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : ('a -> 'acc -> 'acc) -> 'a array -> 'acc -> 'acc @since 4.00.0: val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a @since 3.07.0: val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b *) val sort : ('a -> 'a -> int) -> 'a array -> unit (** Alias for {!Array.sort} *) val stable_sort : ('a -> 'a -> int) -> 'a array -> unit (** Alias for {!Array.stable_sort} *) val fast_sort : ('a -> 'a -> int) -> 'a array -> unit (** Alias for {!Array.fast_sort} *) external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get" (** Alias for {!Array.unsafe_get} *) external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set" (** Alias for {!Array.unsafe_set} *) end ocaml-stdcompat-20~git20240529/stdcompat__atomic.ml.in000066400000000000000000000010321463722102200225410ustar00rootroot00000000000000@BEGIN_FROM_4_12_0@ include Atomic @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a ref let make = ref let get = (!) let set = (:=) let exchange r new_value = let old_value = !r in r := new_value; old_value let compare_and_set r seen v = if !r = seen then begin r := v; true end else false let fetch_and_add r n = let old_value = !r in r := old_value + n; old_value let incr = incr let decr = decr @END_BEFORE_4_12_0@ @BEGIN_BEFORE_5_2_0@ let make_contended = make @END_BEFORE_5_2_0@ ocaml-stdcompat-20~git20240529/stdcompat__atomic.mli.in000066400000000000000000000000361463722102200227150ustar00rootroot00000000000000include Stdcompat__atomic_s.S ocaml-stdcompat-20~git20240529/stdcompat__atomic_s.mli.in000066400000000000000000000020071463722102200232370ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_12_0@ @BEGIN_FROM_4_12_0@ type !'a t = 'a Atomic.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a Atomic.t @END_BEFORE_4_12_0@ @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ (** @since 4.12.0: type !'a t *) val make_contended : 'a -> 'a t (** @since 5.2.0: val make_contended : 'a -> 'a t *) val make : 'a -> 'a t (** @since 4.12.0: val make : 'a -> 'a t *) val get : 'a t -> 'a (** @since 4.12.0: val get : 'a t -> 'a *) val set : 'a t -> 'a -> unit (** @since 4.12.0: val set : 'a t -> 'a -> unit *) val exchange : 'a t -> 'a -> 'a (** @since 4.12.0: val exchange : 'a t -> 'a -> 'a *) val compare_and_set : 'a t -> 'a -> 'a -> bool (** @since 4.12.0: val compare_and_set : 'a t -> 'a -> 'a -> bool *) val fetch_and_add : int t -> int -> int (** @since 4.12.0: val fetch_and_add : int t -> int -> int *) val incr : int t -> unit (** @since 4.12.0: val incr : int t -> unit *) val decr : int t -> unit (** @since 4.12.0: val decr : int t -> unit *) end ocaml-stdcompat-20~git20240529/stdcompat__bool.ml.in000066400000000000000000000010041463722102200222170ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Bool @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type t = bool = | false | true let not = not external (&&) : bool -> bool -> bool = "%sequand" external (||) : bool -> bool -> bool = "%sequor" let equal = ( = ) let compare = compare let to_int b = if b then 1 else 0 let to_float b = if b then 1. else 0. let to_string = string_of_bool @END_BEFORE_4_08_0@ @BEGIN_BEFORE_5_1_0@ let hash = Hashtbl.hash let seeded_hash = Stdcompat__hashtbl.seeded_hash @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__bool.mli.in000066400000000000000000000000341463722102200223720ustar00rootroot00000000000000include Stdcompat__bool_s.S ocaml-stdcompat-20~git20240529/stdcompat__bool_s.mli.in000066400000000000000000000035241463722102200227230ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type t = bool = | false | true @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type t = bool = | false | true @END_BEFORE_4_08_0@ (** @since 4.08.0: type t = bool = | false | true *) val seeded_hash : int -> bool -> int (** @since 5.1.0: val seeded_hash : int -> bool -> int *) val hash : bool -> int (** @since 5.1.0: val hash : bool -> int *) val not : bool -> bool (** @since 4.08.0: val not : bool -> bool *) @BEGIN_FROM_4_08_0@ external (&&) : bool -> bool -> bool = "%sequand" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external (&&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external (&&) : bool -> bool -> bool = "%sequand" @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external (&&) : bool -> bool -> bool = "%sequand" *) @BEGIN_FROM_4_08_0@ external (||) : bool -> bool -> bool = "%sequor" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external (||) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external (||) : bool -> bool -> bool = "%sequor" @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external (||) : bool -> bool -> bool = "%sequor" *) val equal : bool -> bool -> bool (** @since 4.08.0: val equal : bool -> bool -> bool *) val compare : bool -> bool -> int (** @since 4.08.0: val compare : bool -> bool -> int *) val to_int : bool -> int (** @since 4.08.0: val to_int : bool -> int *) val to_float : bool -> float (** @since 4.08.0: val to_float : bool -> float *) val to_string : bool -> string (** @since 4.08.0: val to_string : bool -> string *) end ocaml-stdcompat-20~git20240529/stdcompat__buffer.ml.in000066400000000000000000000125071463722102200225470ustar00rootroot00000000000000include Buffer @BEGIN_BEFORE_4_08_0@ let add_uint8 b v = add_char b (char_of_int (v land 0xFF)) let add_int8 b v = add_uint8 b v let add_uint16_le b v = add_uint8 b v; add_uint8 b (v lsr 8) let add_uint16_be b v = add_uint8 b (v lsr 8); add_uint8 b v let add_uint16_ne b v = if @BIG_ENDIAN@ then add_uint16_be b v else add_uint16_le b v let add_int16_le = add_uint16_le let add_int16_be = add_uint16_be let add_int16_ne = add_uint16_ne let add_int32_le b v = add_uint8 b (Int32.to_int v); add_uint8 b (Int32.to_int (Int32.shift_right v 8)); add_uint8 b (Int32.to_int (Int32.shift_right v 16)); add_uint8 b (Int32.to_int (Int32.shift_right v 24)) let add_int32_be b v = add_uint8 b (Int32.to_int (Int32.shift_right v 24)); add_uint8 b (Int32.to_int (Int32.shift_right v 16)); add_uint8 b (Int32.to_int (Int32.shift_right v 8)); add_uint8 b (Int32.to_int v) let add_int32_ne b v = if @BIG_ENDIAN@ then add_int32_be b v else add_int32_le b v let add_int64_le b v = add_uint8 b (Int64.to_int v); add_uint8 b (Int64.to_int (Int64.shift_right v 8)); add_uint8 b (Int64.to_int (Int64.shift_right v 16)); add_uint8 b (Int64.to_int (Int64.shift_right v 24)); add_uint8 b (Int64.to_int (Int64.shift_right v 32)); add_uint8 b (Int64.to_int (Int64.shift_right v 40)); add_uint8 b (Int64.to_int (Int64.shift_right v 48)); add_uint8 b (Int64.to_int (Int64.shift_right v 56)) let add_int64_be b v = add_uint8 b (Int64.to_int (Int64.shift_right v 56)); add_uint8 b (Int64.to_int (Int64.shift_right v 48)); add_uint8 b (Int64.to_int (Int64.shift_right v 40)); add_uint8 b (Int64.to_int (Int64.shift_right v 32)); add_uint8 b (Int64.to_int (Int64.shift_right v 24)); add_uint8 b (Int64.to_int (Int64.shift_right v 16)); add_uint8 b (Int64.to_int (Int64.shift_right v 8)); add_uint8 b (Int64.to_int v) let add_int64_ne b v = if @BIG_ENDIAN@ then add_int64_be b v else add_int64_le b v @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_MAGIC@ type internal = { mutable buffer : string; mutable position : int; mutable length : int; initial_buffer : string } @END_WITH_MAGIC@ let add_channel b ic size = @BEGIN_WITH_MAGIC@ let original_offset = pos_in ic in try add_channel b ic size with End_of_file as exc -> let read = pos_in ic - original_offset in let b' = (Obj.magic b : internal) in b'.position <- b'.position + read; raise exc @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let max_size = in_channel_length ic - pos_in ic in add_channel b ic (min size max_size); if max_size < size then raise End_of_file @END_WITHOUT_MAGIC@ @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_02_0@ let to_bytes = contents let add_bytes = add_string let add_subbytes = add_substring @END_BEFORE_4_02_0@ @BEGIN_BEFORE_3_08_0@ let sub buffer offset length = String.sub (contents buffer) offset length let nth buffer offset = (contents buffer).[offset] @END_BEFORE_3_08_0@ @BEGIN_BEFORE_4_05_0@ let truncate b len = let s = sub b 0 len in clear b; add_string b s @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_06_0@ let add_utf_8_uchar b u = if Stdcompat__uchar.is_char u then add_char b (Stdcompat__uchar.unsafe_to_char u) else let i = Stdcompat__uchar.to_int u in if i <= 0x07FF then begin add_char b (Char.unsafe_chr (0xC0 lor (i lsr 6))); add_char b (Char.unsafe_chr (0x80 lor i land 0x3F)); end else if i <= 0xFFFF then begin add_char b (Char.unsafe_chr (0xE0 lor (i lsr 12))); add_char b (Char.unsafe_chr (0x80 lor (i lsr 6) land 0x3F)); add_char b (Char.unsafe_chr (0x80 lor i land 0x3F)); end else begin add_char b (Char.unsafe_chr (0xF0 lor (i lsr 18))); add_char b (Char.unsafe_chr (0x80 lor (i lsr 12) land 0x3F)); add_char b (Char.unsafe_chr (0x80 lor (i lsr 6) land 0x3F)); add_char b (Char.unsafe_chr (0x80 lor i land 0x3F)); end let add_utf_16be_uchar b u = let i = Stdcompat__uchar.to_int u in if i <= 0xFFFF then begin add_char b (Char.unsafe_chr (i lsr 8)); add_char b (Char.unsafe_chr (i land 0xFF)); end else let i = i - 0x10000 in let hi = 0xD800 lor i lsr 10 in let lo = 0xDC00 lor i land 0x3FF in add_char b (Char.unsafe_chr (hi lsr 8)); add_char b (Char.unsafe_chr (hi land 0xFF)); add_char b (Char.unsafe_chr (lo lsr 8)); add_char b (Char.unsafe_chr (lo land 0xFF)) let add_utf_16le_uchar b u = let i = Stdcompat__uchar.to_int u in if i <= 0xFFFF then begin add_char b (Char.unsafe_chr (i land 0xFF)); add_char b (Char.unsafe_chr (i lsr 8)); end else let i = i - 0x10000 in let hi = 0xD800 lor i lsr 10 in let lo = 0xDC00 lor i land 0x3FF in add_char b (Char.unsafe_chr (hi land 0xFF)); add_char b (Char.unsafe_chr (hi lsr 8)); add_char b (Char.unsafe_chr (lo land 0xFF)); add_char b (Char.unsafe_chr (lo lsr 8)) @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_07_0@ let add_seq b seq = Stdcompat__seq.iter (add_char b) seq let of_seq g = let b = create 32 in add_seq b g; b let to_seq b = Stdcompat__tools.vec_to_seq length nth b let to_seqi b = Stdcompat__tools.vec_to_seqi length nth b @END_BEFORE_4_07_0@ @BEGIN_BEFORE_3_11_0@ let blit src srcoff dst dstoff len = String.blit (contents src) srcoff dst dstoff len @END_BEFORE_3_11_0@ ocaml-stdcompat-20~git20240529/stdcompat__buffer.mli.in000066400000000000000000000000361463722102200227120ustar00rootroot00000000000000include Stdcompat__buffer_s.S ocaml-stdcompat-20~git20240529/stdcompat__buffer_s.mli.in000066400000000000000000000120321463722102200232330ustar00rootroot00000000000000module type S = sig type t = Buffer.t (** Alias for {!Buffer.t} *) val add_uint8 : t -> int -> unit (** @since 4.08.0: val add_uint8 : t -> int -> unit *) val add_int8 : t -> int -> unit (** @since 4.08.0: val add_int8 : t -> int -> unit *) val add_uint16_ne : t -> int -> unit (** @since 4.08.0: val add_uint16_ne : t -> int -> unit *) val add_uint16_be : t -> int -> unit (** @since 4.08.0: val add_uint16_be : t -> int -> unit *) val add_uint16_le : t -> int -> unit (** @since 4.08.0: val add_uint16_le : t -> int -> unit *) val add_int16_ne : t -> int -> unit (** @since 4.08.0: val add_int16_ne : t -> int -> unit *) val add_int16_be : t -> int -> unit (** @since 4.08.0: val add_int16_be : t -> int -> unit *) val add_int16_le : t -> int -> unit (** @since 4.08.0: val add_int16_le : t -> int -> unit *) val add_int32_ne : t -> int32 -> unit (** @since 4.08.0: val add_int32_ne : t -> int32 -> unit *) val add_int32_be : t -> int32 -> unit (** @since 4.08.0: val add_int32_be : t -> int32 -> unit *) val add_int32_le : t -> int32 -> unit (** @since 4.08.0: val add_int32_le : t -> int32 -> unit *) val add_int64_ne : t -> int64 -> unit (** @since 4.08.0: val add_int64_ne : t -> int64 -> unit *) val add_int64_be : t -> int64 -> unit (** @since 4.08.0: val add_int64_be : t -> int64 -> unit *) val add_int64_le : t -> int64 -> unit (** @since 4.08.0: val add_int64_le : t -> int64 -> unit *) @BEGIN_FROM_4_07_0@ val to_seq : t -> char Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : t -> char Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : t -> char Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : t -> (int * char) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : t -> (int * char) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : t -> (int * char) Seq.t *) @BEGIN_FROM_4_07_0@ val add_seq : t -> char Seq.t -> unit @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val add_seq : t -> char Stdcompat__seq.t -> unit @END_BEFORE_4_07_0@ (** @since 4.07.0: val add_seq : t -> char Seq.t -> unit *) @BEGIN_FROM_4_07_0@ val of_seq : char Seq.t -> t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : char Stdcompat__seq.t -> t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : char Seq.t -> t *) @BEGIN_FROM_4_06_0@ val add_utf_8_uchar : t -> Uchar.t -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ val add_utf_8_uchar : t -> Stdcompat__uchar.t -> unit @END_BEFORE_4_06_0@ (** @since 4.06.0: val add_utf_8_uchar : t -> Uchar.t -> unit *) @BEGIN_FROM_4_06_0@ val add_utf_16le_uchar : t -> Uchar.t -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ val add_utf_16le_uchar : t -> Stdcompat__uchar.t -> unit @END_BEFORE_4_06_0@ (** @since 4.06.0: val add_utf_16le_uchar : t -> Uchar.t -> unit *) @BEGIN_FROM_4_06_0@ val add_utf_16be_uchar : t -> Uchar.t -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ val add_utf_16be_uchar : t -> Stdcompat__uchar.t -> unit @END_BEFORE_4_06_0@ (** @since 4.06.0: val add_utf_16be_uchar : t -> Uchar.t -> unit *) val truncate : t -> int -> unit (** @since 4.05.0: val truncate : t -> int -> unit *) @BEGIN_FROM_4_02_0@ val to_bytes : t -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val to_bytes : t -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val to_bytes : t -> bytes *) @BEGIN_FROM_4_02_0@ val blit : t -> int -> bytes -> int -> int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val blit : t -> int -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val blit : t -> int -> bytes -> int -> int -> unit *) @BEGIN_FROM_4_02_0@ val add_bytes : t -> bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val add_bytes : t -> Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val add_bytes : t -> bytes -> unit *) @BEGIN_FROM_4_02_0@ val add_subbytes : t -> bytes -> int -> int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val add_subbytes : t -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val add_subbytes : t -> bytes -> int -> int -> unit *) val sub : t -> int -> int -> string (** @since 3.08.0: val sub : t -> int -> int -> string *) val nth : t -> int -> char (** @since 3.08.0: val nth : t -> int -> char *) val create : int -> t (** Alias for {!Buffer.create} *) val contents : t -> string (** Alias for {!Buffer.contents} *) val length : t -> int (** Alias for {!Buffer.length} *) val clear : t -> unit (** Alias for {!Buffer.clear} *) val reset : t -> unit (** Alias for {!Buffer.reset} *) val output_buffer : out_channel -> t -> unit (** Alias for {!Buffer.output_buffer} *) val add_char : t -> char -> unit (** Alias for {!Buffer.add_char} *) val add_string : t -> string -> unit (** Alias for {!Buffer.add_string} *) val add_substring : t -> string -> int -> int -> unit (** Alias for {!Buffer.add_substring} *) val add_substitute : t -> (string -> string) -> string -> unit (** Alias for {!Buffer.add_substitute} *) val add_buffer : t -> t -> unit (** Alias for {!Buffer.add_buffer} *) val add_channel : t -> in_channel -> int -> unit (** Alias for {!Buffer.add_channel} *) end ocaml-stdcompat-20~git20240529/stdcompat__bytes.ml.in000066400000000000000000000563521463722102200224320ustar00rootroot00000000000000@BEGIN_BEFORE_4_02_0@ include String let empty = "" let of_string = copy let to_string = copy let sub_string = sub let extend s left right = let len = left + length s + right in let result = create len in let trim_left = max (- left) 0 in unsafe_blit s trim_left result (max left 0) (length s - trim_left - max (- right) 0); result let blit_string = blit let cat = ( ^ ) let unsafe_of_string s = s let unsafe_to_string s = s let init n f = let s = create n in for i = 0 to n - 1 do s.[i] <- f i done; s let mapi f s = init (length s) (fun i -> f i (unsafe_get s i)) @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_00_0@ let iteri f s = for i = 0 to length s - 1 do f i (unsafe_get s i) done let map f s = init (length s) (fun i -> f (unsafe_get s i)) let is_space = function | ' ' | '\012' | '\n' | '\r' | '\t' -> true | _ -> false let rec rindex_no_space_from i s = if i >= 0 && is_space (unsafe_get s i) then rindex_no_space_from (pred i) s else i let rec index_no_space_between i j s = if i <= j && is_space (unsafe_get s i) then index_no_space_between (succ i) j s else i let trim s = let off_end = rindex_no_space_from (length s - 1) s in let off_start = index_no_space_between 0 off_end s in if off_start > off_end then "" else if off_start = 0 && off_end = length s - 1 then s else sub s off_start (off_end - off_start + 1) @END_BEFORE_4_00_0@ @BEGIN_FROM_4_02_0@ include Bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_05_0@ let index_opt s c = Stdcompat__tools.option_find (index s) c let rindex_opt s c = Stdcompat__tools.option_find (rindex s) c let index_from_opt s i c = Stdcompat__tools.option_find (index_from s i) c let rindex_from_opt s i c = Stdcompat__tools.option_find (rindex_from s i) c @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_03_0@ let uppercase_ascii = uppercase let lowercase_ascii = lowercase let capitalize_ascii = capitalize let uncapitalize_ascii = uncapitalize let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_07_0@ let of_seq g = Stdcompat__buffer.to_bytes (Stdcompat__buffer.of_seq g) let to_seq s = Stdcompat__tools.vec_to_seq length unsafe_get s let to_seqi s = Stdcompat__tools.vec_to_seqi length unsafe_get s @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_08_0@ let pad_sign i w = let pad_width = Stdcompat__sys.int_size - w in (i lsl pad_width) asr pad_width let index_out_of_bounds () = invalid_arg "index out of bounds" let unsafe_get_uint8 b i = int_of_char (get b i) let get_uint8 b i = if i < 0 || i >= length b then index_out_of_bounds (); unsafe_get_uint8 b i let get_int8 b i = pad_sign (get_uint8 b i) 8 let unsafe_get_uint16_le b i = let l = unsafe_get_uint8 b i in let u = unsafe_get_uint8 b (succ i) in l lor u lsl 8 let get_uint16_le b i = if i < 0 || succ i >= length b then index_out_of_bounds (); unsafe_get_uint16_le b i let unsafe_get_uint16_be b i = let u = unsafe_get_uint8 b i in let l = unsafe_get_uint8 b (succ i) in l lor u lsl 8 let get_uint16_be b i = if i < 0 || succ i >= length b then index_out_of_bounds (); unsafe_get_uint16_be b i let get_uint16_ne b i = if Stdcompat__sys.big_endian then get_uint16_be b i else get_uint16_le b i let get_int16_le b i = pad_sign (get_uint16_le b i) 16 let get_int16_be b i = pad_sign (get_uint16_be b i) 16 let get_int16_ne b i = pad_sign (get_uint16_ne b i) 16 let get_int32_le b i = if i < 0 || i + 3 >= length b then index_out_of_bounds (); let i0 = unsafe_get_uint8 b i in let i1 = unsafe_get_uint8 b (i + 1) in let i2 = unsafe_get_uint8 b (i + 2) in let i3 = unsafe_get_uint8 b (i + 3) in Int32.logor (Int32.of_int i0) (Int32.logor (Int32.shift_left (Int32.of_int i1) 8) (Int32.logor (Int32.shift_left (Int32.of_int i2) 16) (Int32.shift_left (Int32.of_int i3) 24))) let get_int32_be b i = if i < 0 || i + 3 >= length b then index_out_of_bounds (); let i3 = unsafe_get_uint8 b i in let i2 = unsafe_get_uint8 b (i + 1) in let i1 = unsafe_get_uint8 b (i + 2) in let i0 = unsafe_get_uint8 b (i + 3) in Int32.logor (Int32.of_int i0) (Int32.logor (Int32.shift_left (Int32.of_int i1) 8) (Int32.logor (Int32.shift_left (Int32.of_int i2) 16) (Int32.shift_left (Int32.of_int i3) 24))) let get_int32_ne b i = if Stdcompat__sys.big_endian then get_int32_be b i else get_int32_le b i let get_int64_le b i = if i < 0 || i + 7 >= length b then index_out_of_bounds (); let i0 = unsafe_get_uint8 b i in let i1 = unsafe_get_uint8 b (i + 1) in let i2 = unsafe_get_uint8 b (i + 2) in let i3 = unsafe_get_uint8 b (i + 3) in let i4 = unsafe_get_uint8 b (i + 4) in let i5 = unsafe_get_uint8 b (i + 5) in let i6 = unsafe_get_uint8 b (i + 6) in let i7 = unsafe_get_uint8 b (i + 7) in Int64.logor (Int64.of_int i0) (Int64.logor (Int64.shift_left (Int64.of_int i1) 8) (Int64.logor (Int64.shift_left (Int64.of_int i2) 16) (Int64.logor (Int64.shift_left (Int64.of_int i3) 24) (Int64.logor (Int64.shift_left (Int64.of_int i4) 32) (Int64.logor (Int64.shift_left (Int64.of_int i5) 40) (Int64.logor (Int64.shift_left (Int64.of_int i6) 48) (Int64.shift_left (Int64.of_int i7) 56))))))) let get_int64_be b i = if i < 0 || i + 7 >= length b then index_out_of_bounds (); let i7 = unsafe_get_uint8 b i in let i6 = unsafe_get_uint8 b (i + 1) in let i5 = unsafe_get_uint8 b (i + 2) in let i4 = unsafe_get_uint8 b (i + 3) in let i3 = unsafe_get_uint8 b (i + 4) in let i2 = unsafe_get_uint8 b (i + 5) in let i1 = unsafe_get_uint8 b (i + 6) in let i0 = unsafe_get_uint8 b (i + 7) in Int64.logor (Int64.of_int i0) (Int64.logor (Int64.shift_left (Int64.of_int i1) 8) (Int64.logor (Int64.shift_left (Int64.of_int i2) 16) (Int64.logor (Int64.shift_left (Int64.of_int i3) 24) (Int64.logor (Int64.shift_left (Int64.of_int i4) 32) (Int64.logor (Int64.shift_left (Int64.of_int i5) 40) (Int64.logor (Int64.shift_left (Int64.of_int i6) 48) (Int64.shift_left (Int64.of_int i7) 56))))))) let get_int64_ne b i = if Stdcompat__sys.big_endian then get_int64_be b i else get_int64_le b i let unsafe_set_uint8 b i v = unsafe_set b i (char_of_int (v land 0xFF)) let set_uint8 b i v = if i < 0 || i >= length b then index_out_of_bounds (); unsafe_set_uint8 b i v let set_int8 = set_uint8 let unsafe_set_uint16_le b i v = unsafe_set_uint8 b i v; unsafe_set_uint8 b (succ i) (v lsr 8) let set_uint16_le b i v = if i < 0 || succ i >= length b then index_out_of_bounds (); unsafe_set_uint16_le b i v let unsafe_set_uint16_be b i v = unsafe_set_uint8 b i (v lsr 8); unsafe_set_uint8 b (succ i) v let set_uint16_be b i v = if i < 0 || succ i >= length b then index_out_of_bounds (); unsafe_set_uint16_be b i v let set_uint16_ne b i v = if Stdcompat__sys.big_endian then set_uint16_be b i v else set_uint16_le b i v let set_int16_le = set_uint16_le let set_int16_be = set_uint16_be let set_int16_ne = set_uint16_ne let set_int32_le b i v = if i < 0 || i + 3 >= length b then index_out_of_bounds (); unsafe_set_uint8 b i (Int32.to_int v); unsafe_set_uint8 b (i + 1) (Int32.to_int (Int32.shift_right v 8)); unsafe_set_uint8 b (i + 2) (Int32.to_int (Int32.shift_right v 16)); unsafe_set_uint8 b (i + 3) (Int32.to_int (Int32.shift_right v 24)) let set_int32_be b i v = if i < 0 || i + 3 >= length b then index_out_of_bounds (); unsafe_set_uint8 b i (Int32.to_int (Int32.shift_right v 24)); unsafe_set_uint8 b (i + 1) (Int32.to_int (Int32.shift_right v 16)); unsafe_set_uint8 b (i + 2) (Int32.to_int (Int32.shift_right v 8)); unsafe_set_uint8 b (i + 3) (Int32.to_int v) let set_int32_ne b i v = if Stdcompat__sys.big_endian then set_int32_be b i v else set_int32_le b i v let set_int64_le b i v = if i < 0 || i + 7 >= length b then index_out_of_bounds (); unsafe_set_uint8 b i (Int64.to_int v); unsafe_set_uint8 b (i + 1) (Int64.to_int (Int64.shift_right v 8)); unsafe_set_uint8 b (i + 2) (Int64.to_int (Int64.shift_right v 16)); unsafe_set_uint8 b (i + 3) (Int64.to_int (Int64.shift_right v 24)); unsafe_set_uint8 b (i + 4) (Int64.to_int (Int64.shift_right v 32)); unsafe_set_uint8 b (i + 5) (Int64.to_int (Int64.shift_right v 40)); unsafe_set_uint8 b (i + 6) (Int64.to_int (Int64.shift_right v 48)); unsafe_set_uint8 b (i + 7) (Int64.to_int (Int64.shift_right v 56)) let set_int64_be b i v = if i < 0 || i + 7 >= length b then index_out_of_bounds (); unsafe_set_uint8 b i (Int64.to_int (Int64.shift_right v 56)); unsafe_set_uint8 b (i + 1) (Int64.to_int (Int64.shift_right v 48)); unsafe_set_uint8 b (i + 2) (Int64.to_int (Int64.shift_right v 40)); unsafe_set_uint8 b (i + 3) (Int64.to_int (Int64.shift_right v 32)); unsafe_set_uint8 b (i + 4) (Int64.to_int (Int64.shift_right v 24)); unsafe_set_uint8 b (i + 5) (Int64.to_int (Int64.shift_right v 16)); unsafe_set_uint8 b (i + 6) (Int64.to_int (Int64.shift_right v 8)); unsafe_set_uint8 b (i + 7) (Int64.to_int v) let set_int64_ne b i v = if Stdcompat__sys.big_endian then set_int64_be b i v else set_int64_le b i v @END_BEFORE_4_08_0@ @BEGIN_FROM_4_08_0@ @BEGIN_BEFORE_4_14_0@ external unsafe_get_uint8 : bytes -> int -> int = "%bytes_unsafe_get" external unsafe_get_uint16_ne : bytes -> int -> int = "%caml_bytes_get16u" external get_uint8 : bytes -> int -> int = "%bytes_safe_get" external get_uint16_ne : bytes -> int -> int = "%caml_bytes_get16" external get_int32_ne : bytes -> int -> int32 = "%caml_bytes_get32" external get_int64_ne : bytes -> int -> int64 = "%caml_bytes_get64" external unsafe_set_uint8 : bytes -> int -> int -> unit = "%bytes_unsafe_set" external unsafe_set_uint16_ne : bytes -> int -> int -> unit = "%caml_bytes_set16u" external set_int8 : bytes -> int -> int -> unit = "%bytes_safe_set" external set_int16_ne : bytes -> int -> int -> unit = "%caml_bytes_set16" external set_int32_ne : bytes -> int -> int32 -> unit = "%caml_bytes_set32" external set_int64_ne : bytes -> int -> int64 -> unit = "%caml_bytes_set64" external swap16 : int -> int = "%bswap16" let unsafe_get_uint16_le b i = if Sys.big_endian then swap16 (unsafe_get_uint16_ne b i) else unsafe_get_uint16_ne b i let unsafe_get_uint16_be b i = if Sys.big_endian then unsafe_get_uint16_ne b i else swap16 (unsafe_get_uint16_ne b i) let unsafe_set_uint16_le b i x = if Sys.big_endian then unsafe_set_uint16_ne b i (swap16 x) else unsafe_set_uint16_ne b i x let unsafe_set_uint16_be b i x = if Sys.big_endian then unsafe_set_uint16_ne b i x else unsafe_set_uint16_ne b i (swap16 x) @END_BEFORE_4_14_0@ @END_FROM_4_08_0@ @BEGIN_BEFORE_4_09_0@ @BEGIN_FROM_4_03_0@ external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external unsafe_blit_string : string -> int -> Stdcompat__init.bytes -> int -> int -> unit = "caml_blit_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_blit_string : string -> int -> Stdcompat__init.bytes -> int -> int -> unit = "blit_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_09_0@ @BEGIN_BEFORE_4_13_0@ let rec fold_left_rec f init bytes i = if i >= length bytes then init else fold_left_rec f (f init (unsafe_get bytes i)) bytes (succ i) let fold_left f init bytes = fold_left_rec f init bytes 0 let rec fold_right_rec f bytes init i = if i = 0 then init else let j = pred i in fold_right_rec f bytes (f (unsafe_get bytes j) init) j let fold_right f bytes init = fold_right_rec f bytes init (length bytes) let rec for_all_rec f bytes i = if i >= length bytes then true else if f (unsafe_get bytes i) then for_all_rec f bytes (succ i) else false let for_all f bytes = for_all_rec f bytes 0 let rec exists_rec f bytes i = if i >= length bytes then false else if f (unsafe_get bytes i) then true else exists_rec f bytes (succ i) let exists f bytes = exists_rec f bytes 0 let rec unsafe_sub_equal bytes0 off0 bytes1 off1 length = if length = 0 then true else if unsafe_get bytes0 off0 = unsafe_get bytes1 off1 then unsafe_sub_equal bytes0 (succ off0) bytes1 (succ off1) (pred length) else false let starts_with ~prefix bytes = length prefix <= length bytes && unsafe_sub_equal bytes 0 prefix 0 (length prefix) let ends_with ~suffix bytes = length suffix <= length bytes && unsafe_sub_equal bytes (length bytes - length suffix) suffix 0 (length suffix) let split_on_char c s = let previous_index = ref (length s) in let accu = ref [] in for i = length s - 1 downto 0 do if unsafe_get s i = c then begin accu := sub s (i + 1) (!previous_index - i - 1) :: !accu; previous_index := i end done; sub s 0 !previous_index :: !accu @END_BEFORE_4_13_0@ @BEGIN_BEFORE_4_14_0@ let dec_invalid = Stdcompat__uchar.utf_decode_invalid let dec_ret n u = Stdcompat__uchar.utf_decode n (Stdcompat__uchar.unsafe_of_int u) (* In case of decoding error, if we error on the first byte, we consume the byte, otherwise we consume the [n] bytes preceeding the erroring byte. This means that if a client uses decodes without caring about validity it naturally replace bogus data with Stdcompat__uchar.rep according to the WHATWG Encoding standard. Other schemes are possible by consulting the number of used bytes on invalid decodes. For more details see https://hsivonen.fi/broken-utf-8/ For this reason in [get_utf_8_uchar] we gradually check the next byte is available rather than doing it immediately after the first byte. Contrast with [is_valid_utf_8]. *) (* UTF-8 *) let not_in_x80_to_xBF b = b lsr 6 <> 0b10 let not_in_xA0_to_xBF b = b lsr 5 <> 0b101 let not_in_x80_to_x9F b = b lsr 5 <> 0b100 let not_in_x90_to_xBF b = b < 0x90 || 0xBF < b let not_in_x80_to_x8F b = b lsr 4 <> 0x8 let utf_8_uchar_2 b0 b1 = ((b0 land 0x1F) lsl 6) lor ((b1 land 0x3F)) let utf_8_uchar_3 b0 b1 b2 = ((b0 land 0x0F) lsl 12) lor ((b1 land 0x3F) lsl 6) lor ((b2 land 0x3F)) let utf_8_uchar_4 b0 b1 b2 b3 = ((b0 land 0x07) lsl 18) lor ((b1 land 0x3F) lsl 12) lor ((b2 land 0x3F) lsl 6) lor ((b3 land 0x3F)) let get_utf_8_uchar b i = let b0 = get_uint8 b i in (* raises if [i] is not a valid index. *) let get = unsafe_get_uint8 in let max = length b - 1 in match Char.unsafe_chr b0 with (* See The Unicode Standard, Table 3.7 *) | '\x00' .. '\x7F' -> dec_ret 1 b0 | '\xC2' .. '\xDF' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else dec_ret 2 (utf_8_uchar_2 b0 b1) | '\xE0' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_xA0_to_xBF b1 then dec_invalid 1 else let i = i + 1 in if i > max then dec_invalid 2 else let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else dec_ret 3 (utf_8_uchar_3 b0 b1 b2) | '\xE1' .. '\xEC' | '\xEE' .. '\xEF' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else let i = i + 1 in if i > max then dec_invalid 2 else let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else dec_ret 3 (utf_8_uchar_3 b0 b1 b2) | '\xED' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_x80_to_x9F b1 then dec_invalid 1 else let i = i + 1 in if i > max then dec_invalid 2 else let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else dec_ret 3 (utf_8_uchar_3 b0 b1 b2) | '\xF0' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_x90_to_xBF b1 then dec_invalid 1 else let i = i + 1 in if i > max then dec_invalid 2 else let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else let i = i + 1 in if i > max then dec_invalid 3 else let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3) | '\xF1' .. '\xF3' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else let i = i + 1 in if i > max then dec_invalid 2 else let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else let i = i + 1 in if i > max then dec_invalid 3 else let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3) | '\xF4' -> let i = i + 1 in if i > max then dec_invalid 1 else let b1 = get b i in if not_in_x80_to_x8F b1 then dec_invalid 1 else let i = i + 1 in if i > max then dec_invalid 2 else let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else let i = i + 1 in if i > max then dec_invalid 3 else let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3) | _ -> dec_invalid 1 let set_utf_8_uchar b i u = let set = unsafe_set_uint8 in let max = length b - 1 in match Stdcompat__uchar.to_int u with | u when u < 0 -> assert false | u when u <= 0x007F -> set_uint8 b i u; 1 | u when u <= 0x07FF -> let last = i + 1 in if last > max then 0 else (set_uint8 b i (0xC0 lor (u lsr 6)); set b last (0x80 lor (u land 0x3F)); 2) | u when u <= 0xFFFF -> let last = i + 2 in if last > max then 0 else (set_uint8 b i (0xE0 lor (u lsr 12)); set b (i + 1) (0x80 lor ((u lsr 6) land 0x3F)); set b last (0x80 lor (u land 0x3F)); 3) | u when u <= 0x10FFFF -> let last = i + 3 in if last > max then 0 else (set_uint8 b i (0xF0 lor (u lsr 18)); set b (i + 1) (0x80 lor ((u lsr 12) land 0x3F)); set b (i + 2) (0x80 lor ((u lsr 6) land 0x3F)); set b last (0x80 lor (u land 0x3F)); 4) | _ -> assert false let is_valid_utf_8 b = let rec loop max b i = if i > max then true else let get = unsafe_get_uint8 in match Char.unsafe_chr (get b i) with | '\x00' .. '\x7F' -> loop max b (i + 1) | '\xC2' .. '\xDF' -> let last = i + 1 in if last > max || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | '\xE0' -> let last = i + 2 in if last > max || not_in_xA0_to_xBF (get b (i + 1)) || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | '\xE1' .. '\xEC' | '\xEE' .. '\xEF' -> let last = i + 2 in if last > max || not_in_x80_to_xBF (get b (i + 1)) || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | '\xED' -> let last = i + 2 in if last > max || not_in_x80_to_x9F (get b (i + 1)) || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | '\xF0' -> let last = i + 3 in if last > max || not_in_x90_to_xBF (get b (i + 1)) || not_in_x80_to_xBF (get b (i + 2)) || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | '\xF1' .. '\xF3' -> let last = i + 3 in if last > max || not_in_x80_to_xBF (get b (i + 1)) || not_in_x80_to_xBF (get b (i + 2)) || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | '\xF4' -> let last = i + 3 in if last > max || not_in_x80_to_x8F (get b (i + 1)) || not_in_x80_to_xBF (get b (i + 2)) || not_in_x80_to_xBF (get b last) then false else loop max b (last + 1) | _ -> false in loop (length b - 1) b 0 (* UTF-16BE *) let get_utf_16be_uchar b i = let get = unsafe_get_uint16_be in let max = length b - 1 in if i < 0 || i > max then invalid_arg "index out of bounds" else if i = max then dec_invalid 1 else match get b i with | u when u < 0xD800 || u > 0xDFFF -> dec_ret 2 u | u when u > 0xDBFF -> dec_invalid 2 | hi -> (* combine [hi] with a low surrogate *) let last = i + 3 in if last > max then dec_invalid (max - i + 1) else match get b (i + 2) with | u when u < 0xDC00 || u > 0xDFFF -> dec_invalid 2 (* retry here *) | lo -> let u = (((hi land 0x3FF) lsl 10) lor (lo land 0x3FF)) + 0x10000 in dec_ret 4 u let set_utf_16be_uchar b i u = let set = unsafe_set_uint16_be in let max = length b - 1 in if i < 0 || i > max then invalid_arg "index out of bounds" else match Stdcompat__uchar.to_int u with | u when u < 0 -> assert false | u when u <= 0xFFFF -> let last = i + 1 in if last > max then 0 else (set b i u; 2) | u when u <= 0x10FFFF -> let last = i + 3 in if last > max then 0 else let u' = u - 0x10000 in let hi = (0xD800 lor (u' lsr 10)) in let lo = (0xDC00 lor (u' land 0x3FF)) in set b i hi; set b (i + 2) lo; 4 | _ -> assert false let is_valid_utf_16be b = let rec loop max b i = let get = unsafe_get_uint16_be in if i > max then true else if i = max then false else match get b i with | u when u < 0xD800 || u > 0xDFFF -> loop max b (i + 2) | u when u > 0xDBFF -> false | _hi -> let last = i + 3 in if last > max then false else match get b (i + 2) with | u when u < 0xDC00 || u > 0xDFFF -> false | _lo -> loop max b (i + 4) in loop (length b - 1) b 0 (* UTF-16LE *) let get_utf_16le_uchar b i = let get = unsafe_get_uint16_le in let max = length b - 1 in if i < 0 || i > max then invalid_arg "index out of bounds" else if i = max then dec_invalid 1 else match get b i with | u when u < 0xD800 || u > 0xDFFF -> dec_ret 2 u | u when u > 0xDBFF -> dec_invalid 2 | hi -> (* combine [hi] with a low surrogate *) let last = i + 3 in if last > max then dec_invalid (max - i + 1) else match get b (i + 2) with | u when u < 0xDC00 || u > 0xDFFF -> dec_invalid 2 (* retry here *) | lo -> let u = (((hi land 0x3FF) lsl 10) lor (lo land 0x3FF)) + 0x10000 in dec_ret 4 u let set_utf_16le_uchar b i u = let set = unsafe_set_uint16_le in let max = length b - 1 in if i < 0 || i > max then invalid_arg "index out of bounds" else match Stdcompat__uchar.to_int u with | u when u < 0 -> assert false | u when u <= 0xFFFF -> let last = i + 1 in if last > max then 0 else (set b i u; 2) | u when u <= 0x10FFFF -> let last = i + 3 in if last > max then 0 else let u' = u - 0x10000 in let hi = (0xD800 lor (u' lsr 10)) in let lo = (0xDC00 lor (u' land 0x3FF)) in set b i hi; set b (i + 2) lo; 4 | _ -> assert false let is_valid_utf_16le b = let rec loop max b i = let get = unsafe_get_uint16_le in if i > max then true else if i = max then false else match get b i with | u when u < 0xD800 || u > 0xDFFF -> loop max b (i + 2) | u when u > 0xDBFF -> false | _hi -> let last = i + 3 in if last > max then false else match get b (i + 2) with | u when u < 0xDC00 || u > 0xDFFF -> false | _lo -> loop max b (i + 4) in loop (length b - 1) b 0 @END_BEFORE_4_14_0@ @BEGIN_BEFORE_5_0_0@ let unsafe_escape b = escaped b @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__bytes.mli.in000066400000000000000000000000351463722102200225660ustar00rootroot00000000000000include Stdcompat__bytes_s.S ocaml-stdcompat-20~git20240529/stdcompat__bytesLabels.ml.in000066400000000000000000000000311463722102200235340ustar00rootroot00000000000000include Stdcompat__bytes ocaml-stdcompat-20~git20240529/stdcompat__bytesLabels.mli.in000066400000000000000000000000431463722102200237100ustar00rootroot00000000000000include Stdcompat__bytesLabels_s.S ocaml-stdcompat-20~git20240529/stdcompat__bytesLabels_s.mli.in000066400000000000000000000673701463722102200242520ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_02_0@ type t = bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: type t = bytes *) @BEGIN_FROM_5_0_0@ val unsafe_escape : bytes -> bytes @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ val unsafe_escape : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_5_0_0@ (** @since 5.0.0: val unsafe_escape : bytes -> bytes *) @BEGIN_FROM_4_14_0@ val get_utf_8_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_8_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_8_uchar : t -> int -> Uchar.utf_decode *) @BEGIN_FROM_4_14_0@ val set_utf_8_uchar : t -> int -> Uchar.t -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val set_utf_8_uchar : t -> int -> Stdcompat__uchar.t -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val set_utf_8_uchar : t -> int -> Uchar.t -> int *) val is_valid_utf_8 : t -> bool (** @since 4.14.0: val is_valid_utf_8 : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16be_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16be_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16be_uchar : t -> int -> Uchar.utf_decode *) @BEGIN_FROM_4_14_0@ val set_utf_16be_uchar : t -> int -> Uchar.t -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val set_utf_16be_uchar : t -> int -> Stdcompat__uchar.t -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val set_utf_16be_uchar : t -> int -> Uchar.t -> int *) val is_valid_utf_16be : t -> bool (** @since 4.14.0: val is_valid_utf_16be : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16le_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16le_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16le_uchar : t -> int -> Uchar.utf_decode *) @BEGIN_FROM_4_14_0@ val set_utf_16le_uchar : t -> int -> Uchar.t -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val set_utf_16le_uchar : t -> int -> Stdcompat__uchar.t -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val set_utf_16le_uchar : t -> int -> Uchar.t -> int *) val is_valid_utf_16le : t -> bool (** @since 4.14.0: val is_valid_utf_16le : t -> bool *) @BEGIN_FROM_5_1_0@ val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> bytes -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_left : f:('a -> char -> 'a) -> init:'a -> bytes -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> Stdcompat__init.bytes -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> bytes -> 'acc @since 4.13.0: val fold_left : f:('a -> char -> 'a) -> init:'a -> bytes -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : f:(char -> 'acc -> 'acc) -> bytes -> init:'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_right : f:(char -> 'a -> 'a) -> bytes -> init:'a -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_right : f:(char -> 'acc -> 'acc) -> Stdcompat__init.bytes -> init:'acc -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : f:(char -> 'acc -> 'acc) -> bytes -> init:'acc -> 'acc @since 4.13.0: val fold_right : f:(char -> 'a -> 'a) -> bytes -> init:'a -> 'a *) @BEGIN_FROM_4_13_0@ val for_all : f:(char -> bool) -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val for_all : f:(char -> bool) -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val for_all : f:(char -> bool) -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val exists : f:(char -> bool) -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val exists : f:(char -> bool) -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val exists : f:(char -> bool) -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val starts_with : prefix:bytes -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val starts_with : prefix:Stdcompat__init.bytes -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val starts_with : prefix:bytes -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val ends_with : suffix:bytes -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val ends_with : suffix:Stdcompat__init.bytes -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val ends_with : suffix:bytes -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val split_on_char : sep:char -> bytes -> bytes list @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val split_on_char : sep:char -> Stdcompat__init.bytes -> Stdcompat__init.bytes list @END_BEFORE_4_13_0@ (** @since 4.13.0: val split_on_char : sep:char -> bytes -> bytes list *) @BEGIN_FROM_4_09_0@ external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] @END_FROM_4_09_0@ @BEGIN_BEFORE_4_09_0@ @BEGIN_FROM_3_08_0@ external unsafe_blit_string : src:string -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_blit_string : src:string -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit = "blit_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_09_0@ (** @since 4.09.0: external unsafe_blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] *) @BEGIN_FROM_4_08_0@ val get_uint8 : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint8 : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint8 : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int8 : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int8 : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int8 : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_uint16_ne : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint16_ne : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint16_ne : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_uint16_be : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint16_be : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint16_be : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_uint16_le : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint16_le : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint16_le : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int16_ne : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int16_ne : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int16_ne : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int16_be : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int16_be : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int16_be : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int16_le : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int16_le : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int16_le : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int32_ne : bytes -> int -> int32 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int32_ne : Stdcompat__init.bytes -> int -> int32 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int32_ne : bytes -> int -> int32 *) @BEGIN_FROM_4_08_0@ val get_int32_be : bytes -> int -> int32 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int32_be : Stdcompat__init.bytes -> int -> int32 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int32_be : bytes -> int -> int32 *) @BEGIN_FROM_4_08_0@ val get_int32_le : bytes -> int -> int32 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int32_le : Stdcompat__init.bytes -> int -> int32 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int32_le : bytes -> int -> int32 *) @BEGIN_FROM_4_08_0@ val get_int64_ne : bytes -> int -> int64 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int64_ne : Stdcompat__init.bytes -> int -> int64 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int64_ne : bytes -> int -> int64 *) @BEGIN_FROM_4_08_0@ val get_int64_be : bytes -> int -> int64 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int64_be : Stdcompat__init.bytes -> int -> int64 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int64_be : bytes -> int -> int64 *) @BEGIN_FROM_4_08_0@ val get_int64_le : bytes -> int -> int64 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int64_le : Stdcompat__init.bytes -> int -> int64 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int64_le : bytes -> int -> int64 *) @BEGIN_FROM_4_08_0@ val set_uint8 : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint8 : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint8 : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int8 : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int8 : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int8 : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_uint16_ne : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint16_ne : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint16_ne : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_uint16_be : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint16_be : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint16_be : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_uint16_le : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint16_le : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint16_le : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int16_ne : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int16_ne : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int16_ne : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int16_be : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int16_be : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int16_be : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int16_le : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int16_le : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int16_le : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int32_ne : bytes -> int -> int32 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int32_ne : Stdcompat__init.bytes -> int -> int32 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int32_ne : bytes -> int -> int32 -> unit *) @BEGIN_FROM_4_08_0@ val set_int32_be : bytes -> int -> int32 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int32_be : Stdcompat__init.bytes -> int -> int32 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int32_be : bytes -> int -> int32 -> unit *) @BEGIN_FROM_4_08_0@ val set_int32_le : bytes -> int -> int32 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int32_le : Stdcompat__init.bytes -> int -> int32 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int32_le : bytes -> int -> int32 -> unit *) @BEGIN_FROM_4_08_0@ val set_int64_ne : bytes -> int -> int64 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int64_ne : Stdcompat__init.bytes -> int -> int64 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int64_ne : bytes -> int -> int64 -> unit *) @BEGIN_FROM_4_08_0@ val set_int64_be : bytes -> int -> int64 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int64_be : Stdcompat__init.bytes -> int -> int64 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int64_be : bytes -> int -> int64 -> unit *) @BEGIN_FROM_4_08_0@ val set_int64_le : bytes -> int -> int64 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int64_le : Stdcompat__init.bytes -> int -> int64 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int64_le : bytes -> int -> int64 -> unit *) @BEGIN_FROM_4_07_0@ val to_seq : t -> char Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : t -> char Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : t -> char Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : t -> (int * char) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : t -> (int * char) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : t -> (int * char) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : char Seq.t -> t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : char Stdcompat__seq.t -> t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : char Seq.t -> t *) @BEGIN_FROM_4_06_0@ val sub_string : bytes -> pos:int -> len:int -> string @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ val sub_string : Stdcompat__init.bytes -> pos:int -> len:int -> string @END_BEFORE_4_06_0@ (** @since 4.06.0: val sub_string : bytes -> pos:int -> len:int -> string *) @BEGIN_FROM_4_05_0@ val extend : bytes -> left:int -> right:int -> bytes @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val extend : Stdcompat__init.bytes -> left:int -> right:int -> Stdcompat__init.bytes @END_BEFORE_4_05_0@ (** @since 4.05.0: val extend : bytes -> left:int -> right:int -> bytes *) @BEGIN_FROM_4_05_0@ val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val blit_string : src:string -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit @END_BEFORE_4_05_0@ (** @since 4.05.0: val blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit *) @BEGIN_FROM_4_05_0@ val cat : bytes -> bytes -> bytes @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val cat : Stdcompat__init.bytes -> Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_05_0@ (** @since 4.05.0: val cat : bytes -> bytes -> bytes *) @BEGIN_FROM_4_05_0@ val index_opt : bytes -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val index_opt : Stdcompat__init.bytes -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val index_opt : bytes -> char -> int option *) @BEGIN_FROM_4_05_0@ val rindex_opt : bytes -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val rindex_opt : Stdcompat__init.bytes -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val rindex_opt : bytes -> char -> int option *) @BEGIN_FROM_4_05_0@ val index_from_opt : bytes -> int -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val index_from_opt : Stdcompat__init.bytes -> int -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val index_from_opt : bytes -> int -> char -> int option *) @BEGIN_FROM_4_05_0@ val rindex_from_opt : bytes -> int -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val rindex_from_opt : Stdcompat__init.bytes -> int -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val rindex_from_opt : bytes -> int -> char -> int option *) @BEGIN_FROM_4_05_0@ val uppercase_ascii : bytes -> bytes @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val uppercase_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_05_0@ (** @since 4.05.0: val uppercase_ascii : bytes -> bytes *) @BEGIN_FROM_4_05_0@ val lowercase_ascii : bytes -> bytes @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val lowercase_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_05_0@ (** @since 4.05.0: val lowercase_ascii : bytes -> bytes *) @BEGIN_FROM_4_05_0@ val capitalize_ascii : bytes -> bytes @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val capitalize_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_05_0@ (** @since 4.05.0: val capitalize_ascii : bytes -> bytes *) @BEGIN_FROM_4_05_0@ val uncapitalize_ascii : bytes -> bytes @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val uncapitalize_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_05_0@ (** @since 4.05.0: val uncapitalize_ascii : bytes -> bytes *) val equal : t -> t -> bool (** @since 4.05.0: val equal : t -> t -> bool *) @BEGIN_FROM_4_04_0@ external length : bytes -> int = "%bytes_length" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external length : bytes -> int = "%string_length" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val length : Stdcompat__init.bytes -> int @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external length : bytes -> int = "%bytes_length" @since 4.02.0: external length : bytes -> int = "%string_length" *) @BEGIN_FROM_4_04_0@ external get : bytes -> int -> char = "%bytes_safe_get" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external get : bytes -> int -> char = "%string_safe_get" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val get : Stdcompat__init.bytes -> int -> char @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external get : bytes -> int -> char = "%bytes_safe_get" @since 4.02.0: external get : bytes -> int -> char = "%string_safe_get" *) @BEGIN_FROM_4_04_0@ external set : bytes -> int -> char -> unit = "%bytes_safe_set" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external set : bytes -> int -> char -> unit = "%string_safe_set" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val set : Stdcompat__init.bytes -> int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external set : bytes -> int -> char -> unit = "%bytes_safe_set" @since 4.02.0: external set : bytes -> int -> char -> unit = "%string_safe_set" *) @BEGIN_FROM_4_04_0@ external create : int -> bytes = "caml_create_bytes" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external create : int -> bytes = "caml_create_string" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val create : int -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external create : int -> bytes = "caml_create_bytes" @since 4.02.0: external create : int -> bytes = "caml_create_string" *) @BEGIN_FROM_4_02_0@ val make : int -> char -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val make : int -> char -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val make : int -> char -> bytes *) @BEGIN_FROM_4_02_0@ val init : int -> f:(int -> char) -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val init : int -> f:(int -> char) -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val init : int -> f:(int -> char) -> bytes *) @BEGIN_FROM_4_02_0@ val empty : bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val empty : Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val empty : bytes *) @BEGIN_FROM_4_02_0@ val copy : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val copy : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val copy : bytes -> bytes *) @BEGIN_FROM_4_02_0@ val of_string : string -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val of_string : string -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val of_string : string -> bytes *) @BEGIN_FROM_4_02_0@ val to_string : bytes -> string @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val to_string : Stdcompat__init.bytes -> string @END_BEFORE_4_02_0@ (** @since 4.02.0: val to_string : bytes -> string *) @BEGIN_FROM_4_02_0@ val sub : bytes -> pos:int -> len:int -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val sub : Stdcompat__init.bytes -> pos:int -> len:int -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val sub : bytes -> pos:int -> len:int -> bytes *) @BEGIN_FROM_4_02_0@ val fill : bytes -> pos:int -> len:int -> char -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val fill : Stdcompat__init.bytes -> pos:int -> len:int -> char -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val fill : bytes -> pos:int -> len:int -> char -> unit *) @BEGIN_FROM_4_02_0@ val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val blit : src:Stdcompat__init.bytes -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit *) @BEGIN_FROM_4_02_0@ val concat : sep:bytes -> bytes list -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val concat : sep:Stdcompat__init.bytes -> Stdcompat__init.bytes list -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val concat : sep:bytes -> bytes list -> bytes *) @BEGIN_FROM_4_02_0@ val iter : f:(char -> unit) -> bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val iter : f:(char -> unit) -> Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val iter : f:(char -> unit) -> bytes -> unit *) @BEGIN_FROM_4_02_0@ val iteri : f:(int -> char -> unit) -> bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val iteri : f:(int -> char -> unit) -> Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val iteri : f:(int -> char -> unit) -> bytes -> unit *) @BEGIN_FROM_4_02_0@ val map : f:(char -> char) -> bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val map : f:(char -> char) -> Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val map : f:(char -> char) -> bytes -> bytes *) @BEGIN_FROM_4_02_0@ val mapi : f:(int -> char -> char) -> bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val mapi : f:(int -> char -> char) -> Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val mapi : f:(int -> char -> char) -> bytes -> bytes *) @BEGIN_FROM_4_02_0@ val trim : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val trim : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val trim : bytes -> bytes *) @BEGIN_FROM_4_02_0@ val escaped : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val escaped : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val escaped : bytes -> bytes *) @BEGIN_FROM_4_02_0@ val index : bytes -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val index : Stdcompat__init.bytes -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val index : bytes -> char -> int *) @BEGIN_FROM_4_02_0@ val rindex : bytes -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val rindex : Stdcompat__init.bytes -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val rindex : bytes -> char -> int *) @BEGIN_FROM_4_02_0@ val index_from : bytes -> int -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val index_from : Stdcompat__init.bytes -> int -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val index_from : bytes -> int -> char -> int *) @BEGIN_FROM_4_02_0@ val rindex_from : bytes -> int -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val rindex_from : Stdcompat__init.bytes -> int -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val rindex_from : bytes -> int -> char -> int *) @BEGIN_FROM_4_02_0@ val contains : bytes -> char -> bool @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val contains : Stdcompat__init.bytes -> char -> bool @END_BEFORE_4_02_0@ (** @since 4.02.0: val contains : bytes -> char -> bool *) @BEGIN_FROM_4_02_0@ val contains_from : bytes -> int -> char -> bool @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val contains_from : Stdcompat__init.bytes -> int -> char -> bool @END_BEFORE_4_02_0@ (** @since 4.02.0: val contains_from : bytes -> int -> char -> bool *) @BEGIN_FROM_4_02_0@ val rcontains_from : bytes -> int -> char -> bool @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val rcontains_from : Stdcompat__init.bytes -> int -> char -> bool @END_BEFORE_4_02_0@ (** @since 4.02.0: val rcontains_from : bytes -> int -> char -> bool *) val compare : t -> t -> int (** @since 4.02.0: val compare : t -> t -> int *) @BEGIN_FROM_4_02_0@ val unsafe_to_string : bytes -> string @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_to_string : Stdcompat__init.bytes -> string @END_BEFORE_4_02_0@ (** @since 4.02.0: val unsafe_to_string : bytes -> string *) @BEGIN_FROM_4_02_0@ val unsafe_of_string : string -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_of_string : string -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val unsafe_of_string : string -> bytes *) @BEGIN_FROM_4_04_0@ external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external unsafe_get : bytes -> int -> char = "%string_unsafe_get" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_get : Stdcompat__init.bytes -> int -> char @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" @since 4.02.0: external unsafe_get : bytes -> int -> char = "%string_unsafe_get" *) @BEGIN_FROM_4_04_0@ external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_set : Stdcompat__init.bytes -> int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" @since 4.02.0: external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" *) @BEGIN_FROM_4_04_0@ external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_03_0@ external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_blit : src:Stdcompat__init.bytes -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_bytes"[@@noalloc ] @since 4.03.0: external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] @since 4.02.0: external unsafe_blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" *) @BEGIN_FROM_4_04_0@ external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes"[@@noalloc ] @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_03_0@ external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_fill : Stdcompat__init.bytes -> pos:int -> len:int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_bytes" [@@noalloc ] @since 4.03.0: external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] @since 4.02.0: external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" *) end ocaml-stdcompat-20~git20240529/stdcompat__bytes_s.mli.in000066400000000000000000000656721463722102200231320ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_02_0@ type t = bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: type t = bytes *) @BEGIN_FROM_5_0_0@ val unsafe_escape : bytes -> bytes @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ val unsafe_escape : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_5_0_0@ (** @since 5.0.0: val unsafe_escape : bytes -> bytes *) @BEGIN_FROM_4_14_0@ val get_utf_8_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_8_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_8_uchar : t -> int -> Uchar.utf_decode *) @BEGIN_FROM_4_14_0@ val set_utf_8_uchar : t -> int -> Uchar.t -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val set_utf_8_uchar : t -> int -> Stdcompat__uchar.t -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val set_utf_8_uchar : t -> int -> Uchar.t -> int *) val is_valid_utf_8 : t -> bool (** @since 4.14.0: val is_valid_utf_8 : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16be_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16be_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16be_uchar : t -> int -> Uchar.utf_decode *) @BEGIN_FROM_4_14_0@ val set_utf_16be_uchar : t -> int -> Uchar.t -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val set_utf_16be_uchar : t -> int -> Stdcompat__uchar.t -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val set_utf_16be_uchar : t -> int -> Uchar.t -> int *) val is_valid_utf_16be : t -> bool (** @since 4.14.0: val is_valid_utf_16be : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16le_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16le_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16le_uchar : t -> int -> Uchar.utf_decode *) @BEGIN_FROM_4_14_0@ val set_utf_16le_uchar : t -> int -> Uchar.t -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val set_utf_16le_uchar : t -> int -> Stdcompat__uchar.t -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val set_utf_16le_uchar : t -> int -> Uchar.t -> int *) val is_valid_utf_16le : t -> bool (** @since 4.14.0: val is_valid_utf_16le : t -> bool *) @BEGIN_FROM_5_1_0@ val fold_left : ('acc -> char -> 'acc) -> 'acc -> bytes -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_left : ('a -> char -> 'a) -> 'a -> bytes -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_left : ('acc -> char -> 'acc) -> 'acc -> Stdcompat__init.bytes -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : ('acc -> char -> 'acc) -> 'acc -> bytes -> 'acc @since 4.13.0: val fold_left : ('a -> char -> 'a) -> 'a -> bytes -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : (char -> 'acc -> 'acc) -> bytes -> 'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_right : (char -> 'a -> 'a) -> bytes -> 'a -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_right : (char -> 'acc -> 'acc) -> Stdcompat__init.bytes -> 'acc -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : (char -> 'acc -> 'acc) -> bytes -> 'acc -> 'acc @since 4.13.0: val fold_right : (char -> 'a -> 'a) -> bytes -> 'a -> 'a *) @BEGIN_FROM_4_13_0@ val for_all : (char -> bool) -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val for_all : (char -> bool) -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val for_all : (char -> bool) -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val exists : (char -> bool) -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val exists : (char -> bool) -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val exists : (char -> bool) -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val starts_with : prefix:bytes -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val starts_with : prefix:Stdcompat__init.bytes -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val starts_with : prefix:bytes -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val ends_with : suffix:bytes -> bytes -> bool @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val ends_with : suffix:Stdcompat__init.bytes -> Stdcompat__init.bytes -> bool @END_BEFORE_4_13_0@ (** @since 4.13.0: val ends_with : suffix:bytes -> bytes -> bool *) @BEGIN_FROM_4_13_0@ val split_on_char : char -> bytes -> bytes list @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val split_on_char : char -> Stdcompat__init.bytes -> Stdcompat__init.bytes list @END_BEFORE_4_13_0@ (** @since 4.13.0: val split_on_char : char -> bytes -> bytes list *) @BEGIN_FROM_4_09_0@ external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] @END_FROM_4_09_0@ @BEGIN_BEFORE_4_09_0@ @BEGIN_FROM_3_08_0@ external unsafe_blit_string : string -> int -> Stdcompat__init.bytes -> int -> int -> unit = "caml_blit_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_blit_string : string -> int -> Stdcompat__init.bytes -> int -> int -> unit = "blit_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_09_0@ (** @since 4.09.0: external unsafe_blit_string : string -> int -> bytes -> int -> int -> unit = "caml_blit_string" [@@noalloc ] *) @BEGIN_FROM_4_08_0@ val get_uint8 : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint8 : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint8 : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int8 : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int8 : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int8 : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_uint16_ne : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint16_ne : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint16_ne : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_uint16_be : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint16_be : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint16_be : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_uint16_le : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_uint16_le : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_uint16_le : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int16_ne : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int16_ne : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int16_ne : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int16_be : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int16_be : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int16_be : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int16_le : bytes -> int -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int16_le : Stdcompat__init.bytes -> int -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int16_le : bytes -> int -> int *) @BEGIN_FROM_4_08_0@ val get_int32_ne : bytes -> int -> int32 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int32_ne : Stdcompat__init.bytes -> int -> int32 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int32_ne : bytes -> int -> int32 *) @BEGIN_FROM_4_08_0@ val get_int32_be : bytes -> int -> int32 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int32_be : Stdcompat__init.bytes -> int -> int32 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int32_be : bytes -> int -> int32 *) @BEGIN_FROM_4_08_0@ val get_int32_le : bytes -> int -> int32 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int32_le : Stdcompat__init.bytes -> int -> int32 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int32_le : bytes -> int -> int32 *) @BEGIN_FROM_4_08_0@ val get_int64_ne : bytes -> int -> int64 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int64_ne : Stdcompat__init.bytes -> int -> int64 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int64_ne : bytes -> int -> int64 *) @BEGIN_FROM_4_08_0@ val get_int64_be : bytes -> int -> int64 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int64_be : Stdcompat__init.bytes -> int -> int64 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int64_be : bytes -> int -> int64 *) @BEGIN_FROM_4_08_0@ val get_int64_le : bytes -> int -> int64 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_int64_le : Stdcompat__init.bytes -> int -> int64 @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_int64_le : bytes -> int -> int64 *) @BEGIN_FROM_4_08_0@ val set_uint8 : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint8 : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint8 : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int8 : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int8 : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int8 : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_uint16_ne : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint16_ne : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint16_ne : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_uint16_be : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint16_be : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint16_be : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_uint16_le : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_uint16_le : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_uint16_le : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int16_ne : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int16_ne : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int16_ne : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int16_be : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int16_be : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int16_be : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int16_le : bytes -> int -> int -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int16_le : Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int16_le : bytes -> int -> int -> unit *) @BEGIN_FROM_4_08_0@ val set_int32_ne : bytes -> int -> int32 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int32_ne : Stdcompat__init.bytes -> int -> int32 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int32_ne : bytes -> int -> int32 -> unit *) @BEGIN_FROM_4_08_0@ val set_int32_be : bytes -> int -> int32 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int32_be : Stdcompat__init.bytes -> int -> int32 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int32_be : bytes -> int -> int32 -> unit *) @BEGIN_FROM_4_08_0@ val set_int32_le : bytes -> int -> int32 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int32_le : Stdcompat__init.bytes -> int -> int32 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int32_le : bytes -> int -> int32 -> unit *) @BEGIN_FROM_4_08_0@ val set_int64_ne : bytes -> int -> int64 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int64_ne : Stdcompat__init.bytes -> int -> int64 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int64_ne : bytes -> int -> int64 -> unit *) @BEGIN_FROM_4_08_0@ val set_int64_be : bytes -> int -> int64 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int64_be : Stdcompat__init.bytes -> int -> int64 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int64_be : bytes -> int -> int64 -> unit *) @BEGIN_FROM_4_08_0@ val set_int64_le : bytes -> int -> int64 -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val set_int64_le : Stdcompat__init.bytes -> int -> int64 -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_int64_le : bytes -> int -> int64 -> unit *) @BEGIN_FROM_4_07_0@ val to_seq : t -> char Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : t -> char Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : t -> char Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : t -> (int * char) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : t -> (int * char) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : t -> (int * char) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : char Seq.t -> t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : char Stdcompat__seq.t -> t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : char Seq.t -> t *) @BEGIN_FROM_4_05_0@ val index_opt : bytes -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val index_opt : Stdcompat__init.bytes -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val index_opt : bytes -> char -> int option *) @BEGIN_FROM_4_05_0@ val rindex_opt : bytes -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val rindex_opt : Stdcompat__init.bytes -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val rindex_opt : bytes -> char -> int option *) @BEGIN_FROM_4_05_0@ val index_from_opt : bytes -> int -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val index_from_opt : Stdcompat__init.bytes -> int -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val index_from_opt : bytes -> int -> char -> int option *) @BEGIN_FROM_4_05_0@ val rindex_from_opt : bytes -> int -> char -> int option @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val rindex_from_opt : Stdcompat__init.bytes -> int -> char -> int option @END_BEFORE_4_05_0@ (** @since 4.05.0: val rindex_from_opt : bytes -> int -> char -> int option *) @BEGIN_FROM_4_03_0@ val uppercase_ascii : bytes -> bytes @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val uppercase_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_03_0@ (** @since 4.03.0: val uppercase_ascii : bytes -> bytes *) @BEGIN_FROM_4_03_0@ val lowercase_ascii : bytes -> bytes @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val lowercase_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_03_0@ (** @since 4.03.0: val lowercase_ascii : bytes -> bytes *) @BEGIN_FROM_4_03_0@ val capitalize_ascii : bytes -> bytes @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val capitalize_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_03_0@ (** @since 4.03.0: val capitalize_ascii : bytes -> bytes *) @BEGIN_FROM_4_03_0@ val uncapitalize_ascii : bytes -> bytes @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val uncapitalize_ascii : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_03_0@ (** @since 4.03.0: val uncapitalize_ascii : bytes -> bytes *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) @BEGIN_FROM_4_04_0@ external length : bytes -> int = "%bytes_length" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external length : bytes -> int = "%string_length" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val length : Stdcompat__init.bytes -> int @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external length : bytes -> int = "%bytes_length" @since 4.02.0: external length : bytes -> int = "%string_length" *) @BEGIN_FROM_4_04_0@ external get : bytes -> int -> char = "%bytes_safe_get" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external get : bytes -> int -> char = "%string_safe_get" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val get : Stdcompat__init.bytes -> int -> char @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external get : bytes -> int -> char = "%bytes_safe_get" @since 4.02.0: external get : bytes -> int -> char = "%string_safe_get" *) @BEGIN_FROM_4_04_0@ external set : bytes -> int -> char -> unit = "%bytes_safe_set" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external set : bytes -> int -> char -> unit = "%string_safe_set" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val set : Stdcompat__init.bytes -> int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external set : bytes -> int -> char -> unit = "%bytes_safe_set" @since 4.02.0: external set : bytes -> int -> char -> unit = "%string_safe_set" *) @BEGIN_FROM_4_04_0@ external create : int -> bytes = "caml_create_bytes" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external create : int -> bytes = "caml_create_string" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val create : int -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external create : int -> bytes = "caml_create_bytes" @since 4.02.0: external create : int -> bytes = "caml_create_string" *) @BEGIN_FROM_4_02_0@ val make : int -> char -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val make : int -> char -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val make : int -> char -> bytes *) @BEGIN_FROM_4_02_0@ val init : int -> (int -> char) -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val init : int -> (int -> char) -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val init : int -> (int -> char) -> bytes *) @BEGIN_FROM_4_02_0@ val empty : bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val empty : Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val empty : bytes *) @BEGIN_FROM_4_02_0@ val copy : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val copy : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val copy : bytes -> bytes *) @BEGIN_FROM_4_02_0@ val of_string : string -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val of_string : string -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val of_string : string -> bytes *) @BEGIN_FROM_4_02_0@ val to_string : bytes -> string @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val to_string : Stdcompat__init.bytes -> string @END_BEFORE_4_02_0@ (** @since 4.02.0: val to_string : bytes -> string *) @BEGIN_FROM_4_02_0@ val sub : bytes -> int -> int -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val sub : Stdcompat__init.bytes -> int -> int -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val sub : bytes -> int -> int -> bytes *) @BEGIN_FROM_4_02_0@ val sub_string : bytes -> int -> int -> string @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val sub_string : Stdcompat__init.bytes -> int -> int -> string @END_BEFORE_4_02_0@ (** @since 4.02.0: val sub_string : bytes -> int -> int -> string *) @BEGIN_FROM_4_02_0@ val extend : bytes -> int -> int -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val extend : Stdcompat__init.bytes -> int -> int -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val extend : bytes -> int -> int -> bytes *) @BEGIN_FROM_4_02_0@ val fill : bytes -> int -> int -> char -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val fill : Stdcompat__init.bytes -> int -> int -> char -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val fill : bytes -> int -> int -> char -> unit *) @BEGIN_FROM_4_02_0@ val blit : bytes -> int -> bytes -> int -> int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val blit : Stdcompat__init.bytes -> int -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val blit : bytes -> int -> bytes -> int -> int -> unit *) @BEGIN_FROM_4_02_0@ val blit_string : string -> int -> bytes -> int -> int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val blit_string : string -> int -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val blit_string : string -> int -> bytes -> int -> int -> unit *) @BEGIN_FROM_4_02_0@ val concat : bytes -> bytes list -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val concat : Stdcompat__init.bytes -> Stdcompat__init.bytes list -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val concat : bytes -> bytes list -> bytes *) @BEGIN_FROM_4_02_0@ val cat : bytes -> bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val cat : Stdcompat__init.bytes -> Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val cat : bytes -> bytes -> bytes *) @BEGIN_FROM_4_02_0@ val iter : (char -> unit) -> bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val iter : (char -> unit) -> Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val iter : (char -> unit) -> bytes -> unit *) @BEGIN_FROM_4_02_0@ val iteri : (int -> char -> unit) -> bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val iteri : (int -> char -> unit) -> Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val iteri : (int -> char -> unit) -> bytes -> unit *) @BEGIN_FROM_4_02_0@ val map : (char -> char) -> bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val map : (char -> char) -> Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val map : (char -> char) -> bytes -> bytes *) @BEGIN_FROM_4_02_0@ val mapi : (int -> char -> char) -> bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val mapi : (int -> char -> char) -> Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val mapi : (int -> char -> char) -> bytes -> bytes *) @BEGIN_FROM_4_02_0@ val trim : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val trim : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val trim : bytes -> bytes *) @BEGIN_FROM_4_02_0@ val escaped : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val escaped : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val escaped : bytes -> bytes *) @BEGIN_FROM_4_02_0@ val index : bytes -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val index : Stdcompat__init.bytes -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val index : bytes -> char -> int *) @BEGIN_FROM_4_02_0@ val rindex : bytes -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val rindex : Stdcompat__init.bytes -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val rindex : bytes -> char -> int *) @BEGIN_FROM_4_02_0@ val index_from : bytes -> int -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val index_from : Stdcompat__init.bytes -> int -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val index_from : bytes -> int -> char -> int *) @BEGIN_FROM_4_02_0@ val rindex_from : bytes -> int -> char -> int @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val rindex_from : Stdcompat__init.bytes -> int -> char -> int @END_BEFORE_4_02_0@ (** @since 4.02.0: val rindex_from : bytes -> int -> char -> int *) @BEGIN_FROM_4_02_0@ val contains : bytes -> char -> bool @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val contains : Stdcompat__init.bytes -> char -> bool @END_BEFORE_4_02_0@ (** @since 4.02.0: val contains : bytes -> char -> bool *) @BEGIN_FROM_4_02_0@ val contains_from : bytes -> int -> char -> bool @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val contains_from : Stdcompat__init.bytes -> int -> char -> bool @END_BEFORE_4_02_0@ (** @since 4.02.0: val contains_from : bytes -> int -> char -> bool *) @BEGIN_FROM_4_02_0@ val rcontains_from : bytes -> int -> char -> bool @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val rcontains_from : Stdcompat__init.bytes -> int -> char -> bool @END_BEFORE_4_02_0@ (** @since 4.02.0: val rcontains_from : bytes -> int -> char -> bool *) val compare : t -> t -> int (** @since 4.02.0: val compare : t -> t -> int *) @BEGIN_FROM_4_02_0@ val unsafe_to_string : bytes -> string @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_to_string : Stdcompat__init.bytes -> string @END_BEFORE_4_02_0@ (** @since 4.02.0: val unsafe_to_string : bytes -> string *) @BEGIN_FROM_4_02_0@ val unsafe_of_string : string -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_of_string : string -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ (** @since 4.02.0: val unsafe_of_string : string -> bytes *) @BEGIN_FROM_4_04_0@ external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external unsafe_get : bytes -> int -> char = "%string_unsafe_get" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_get : Stdcompat__init.bytes -> int -> char @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get" @since 4.02.0: external unsafe_get : bytes -> int -> char = "%string_unsafe_get" *) @BEGIN_FROM_4_04_0@ external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_set : Stdcompat__init.bytes -> int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set" @since 4.02.0: external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" *) @BEGIN_FROM_4_04_0@ external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ] @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_03_0@ external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_string" "noalloc" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_blit : Stdcompat__init.bytes -> int -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes" [@@noalloc ] @since 4.03.0: external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] @since 4.02.0: external unsafe_blit : bytes -> int -> bytes -> int -> int -> unit = "caml_blit_string" "noalloc" *) @BEGIN_FROM_4_04_0@ external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_03_0@ external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string" "noalloc" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val unsafe_fill : Stdcompat__init.bytes -> int -> int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_04_0@ (** @since 4.04.0: external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ] @since 4.03.0: external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] @since 4.02.0: external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string" "noalloc" *) end ocaml-stdcompat-20~git20240529/stdcompat__char.ml.in000066400000000000000000000004321463722102200222050ustar00rootroot00000000000000include Char @BEGIN_BEFORE_4_03_0@ let lowercase_ascii = Char.lowercase let uppercase_ascii = Char.uppercase let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_5_1_0@ let hash = Hashtbl.hash let seeded_hash = Stdcompat__hashtbl.seeded_hash @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__char.mli.in000066400000000000000000000000341463722102200223540ustar00rootroot00000000000000include Stdcompat__char_s.S ocaml-stdcompat-20~git20240529/stdcompat__char_s.mli.in000066400000000000000000000014601463722102200227020ustar00rootroot00000000000000module type S = sig type t = char (** Alias for {!Char.t} *) val seeded_hash : int -> t -> int (** @since 5.1.0: val seeded_hash : int -> t -> int *) val hash : t -> int (** @since 5.1.0: val hash : t -> int *) val lowercase_ascii : char -> char (** @since 4.03.0: val lowercase_ascii : char -> char *) val uppercase_ascii : char -> char (** @since 4.03.0: val uppercase_ascii : char -> char *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) external code : char -> int = "%identity" (** Alias for {!Char.code} *) val chr : int -> char (** Alias for {!Char.chr} *) val escaped : char -> string (** Alias for {!Char.escaped} *) val compare : t -> t -> int (** Alias for {!Char.compare} *) external unsafe_chr : int -> char = "%identity" (** Alias for {!Char.unsafe_chr} *) end ocaml-stdcompat-20~git20240529/stdcompat__digest.ml.in000066400000000000000000000035371463722102200225600ustar00rootroot00000000000000include Digest @BEGIN_BEFORE_5_2_0@ module type S = sig type t = string val hash_length : int val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t val channel : in_channel -> int -> t val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t end module MD5 : S = struct let hash_length = 16 include Digest @BEGIN_BEFORE_4_03_0@ let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_02_0@ let bytes = string let subbytes = substring let compare = compare @END_BEFORE_4_02_0@ @BEGIN_FROM_4_00_0@ let of_hex = from_hex @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ let of_hex s = if String.length s <> 32 then invalid_arg "Digest.from_hex"; let digit c = match c with | '0'..'9' -> Char.code c - Char.code '0' | 'A'..'F' -> Char.code c - Char.code 'A' + 10 | 'a'..'f' -> Char.code c - Char.code 'a' + 10 | _ -> raise (Invalid_argument "Digest.from_hex") in let byte i = digit s.[i] lsl 4 + digit s.[i+1] in let result = String.create 16 in for i = 0 to 15 do String.set result i (Char.chr (byte (2 * i))); done; result @END_BEFORE_4_00_0@ end include MD5 external channel : in_channel -> int -> t = "caml_md5_chan" @BEGIN_BEFORE_4_00_0@ let from_hex = of_hex @END_BEFORE_4_00_0@ module BLAKE2 (X : sig val hash_length : int end) : S = struct include MD5 let hash_length = X.hash_length end module BLAKE128 = BLAKE2 (struct let hash_length = 16 end) module BLAKE256 = BLAKE2 (struct let hash_length = 32 end) module BLAKE512 = BLAKE2 (struct let hash_length = 64 end) @END_BEFORE_5_2_0@ ocaml-stdcompat-20~git20240529/stdcompat__digest.mli.in000066400000000000000000000000361463722102200227200ustar00rootroot00000000000000include Stdcompat__digest_s.S ocaml-stdcompat-20~git20240529/stdcompat__digest_s.mli.in000066400000000000000000000075711463722102200232550ustar00rootroot00000000000000module type S = sig type t = string (** Alias for {!Digest.t} *) @BEGIN_FROM_5_2_0@ module type S = sig type t = string val hash_length : int val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t val channel : in_channel -> int -> t val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t end @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module type S = sig type t = string val hash_length : int val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : Stdcompat__init.bytes -> t val substring : string -> int -> int -> t val subbytes : Stdcompat__init.bytes -> int -> int -> t val channel : in_channel -> int -> t val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t end @END_BEFORE_5_2_0@ (** @since 5.2.0: module type S = sig type t = string val hash_length : int val compare : t -> t -> int val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t val substring : string -> int -> int -> t val subbytes : bytes -> int -> int -> t val channel : in_channel -> int -> t val file : string -> t val output : out_channel -> t -> unit val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t end *) @BEGIN_FROM_5_2_0@ module BLAKE128 = Digest.BLAKE128 @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module BLAKE128 : S @END_BEFORE_5_2_0@ (** @since 5.2.0: module BLAKE128 = Digest.BLAKE128 *) @BEGIN_FROM_5_2_0@ module BLAKE256 = Digest.BLAKE256 @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module BLAKE256 : S @END_BEFORE_5_2_0@ (** @since 5.2.0: module BLAKE256 = Digest.BLAKE256 *) @BEGIN_FROM_5_2_0@ module BLAKE512 = Digest.BLAKE512 @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module BLAKE512 : S @END_BEFORE_5_2_0@ (** @since 5.2.0: module BLAKE512 = Digest.BLAKE512 *) @BEGIN_FROM_5_2_0@ module MD5 = Digest.MD5 @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module MD5 : S @END_BEFORE_5_2_0@ (** @since 5.2.0: module MD5 = Digest.MD5 *) val of_hex : string -> t (** @since 5.2.0: val of_hex : string -> t *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) @BEGIN_FROM_4_02_0@ val bytes : bytes -> t @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val bytes : Stdcompat__init.bytes -> t @END_BEFORE_4_02_0@ (** @since 4.02.0: val bytes : bytes -> t *) @BEGIN_FROM_4_02_0@ val subbytes : bytes -> int -> int -> t @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val subbytes : Stdcompat__init.bytes -> int -> int -> t @END_BEFORE_4_02_0@ (** @since 4.02.0: val subbytes : bytes -> int -> int -> t *) val compare : t -> t -> int (** @since 4.00.0: val compare : t -> t -> int *) val from_hex : string -> t (** @since 4.00.0: val from_hex : string -> t *) val string : string -> t (** Alias for {!Digest.string} *) val substring : string -> int -> int -> t (** Alias for {!Digest.substring} *) @BEGIN_FROM_5_2_0@ val channel : in_channel -> int -> t @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ @BEGIN_FROM_3_08_0@ external channel : in_channel -> int -> t = "caml_md5_chan" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external channel : in_channel -> int -> t = "md5_chan" @END_BEFORE_3_08_0@ @END_BEFORE_5_2_0@ (** @since 5.2.0: val channel : in_channel -> int -> t @since 3.08.0: external channel : in_channel -> int -> t = "caml_md5_chan" @since 3.07.0: external channel : in_channel -> int -> t = "md5_chan" *) val file : string -> t (** Alias for {!Digest.file} *) val output : out_channel -> t -> unit (** Alias for {!Digest.output} *) val input : in_channel -> t (** Alias for {!Digest.input} *) val to_hex : t -> string (** Alias for {!Digest.to_hex} *) end ocaml-stdcompat-20~git20240529/stdcompat__domain.ml.in000066400000000000000000000023221463722102200225370ustar00rootroot00000000000000@BEGIN_FROM_5_0_0@ include Domain @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_4_12_0@ type !'a t = 'a @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a @END_BEFORE_4_12_0@ type id = int module DLS = struct type 'a key = { split_from_parent: ('a -> 'a) option; f: unit -> 'a; mutable value: 'a option; } let new_key ?split_from_parent f = { split_from_parent; f; value = None } let get key = match key.value with | Some value -> value | None -> let value = key.f () in key.value <- Some value; value let set key value = key.value <- Some value end let before_first_spawn_list = ref (Some []) let spawn f = begin match !before_first_spawn_list with | None -> () | Some list -> List.iter (fun f -> f ()) (List.rev list); before_first_spawn_list := None end; f () let join v = v let get_id _v = 0 let self () = 0 let before_first_spawn f = match !before_first_spawn_list with | None -> invalid_arg "Already spawned" | Some list -> before_first_spawn_list := Some (f :: list) let at_exit f = at_exit f let cpu_relax () = () let is_main_domain () = true let recommended_domain_count () = 1 @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__domain.mli.in000066400000000000000000000000361463722102200227100ustar00rootroot00000000000000include Stdcompat__domain_s.S ocaml-stdcompat-20~git20240529/stdcompat__domain_s.mli.in000066400000000000000000000031201463722102200232270ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_5_0_0@ @BEGIN_FROM_4_12_0@ type !'a t = 'a Domain.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a Domain.t @END_BEFORE_4_12_0@ @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ type 'a t @END_BEFORE_5_0_0@ (** @since 5.0.0: type !'a t *) @BEGIN_FROM_5_0_0@ type id = Domain.id @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_3_11_0@ type id = private int @END_FROM_3_11_0@ @BEGIN_BEFORE_3_11_0@ type id = int @END_BEFORE_3_11_0@ @END_BEFORE_5_0_0@ (** @since 5.0.0: type id = Domain.id *) @BEGIN_FROM_5_0_0@ module DLS = Domain.DLS @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module DLS : sig type 'a key val new_key : ?split_from_parent:('a -> 'a) -> (unit -> 'a) -> 'a key val get : 'a key -> 'a val set : 'a key -> 'a -> unit end @END_BEFORE_5_0_0@ (** @since 5.0.0: module DLS = Domain.DLS *) val spawn : (unit -> 'a) -> 'a t (** @since 5.0.0: val spawn : (unit -> 'a) -> 'a t *) val join : 'a t -> 'a (** @since 5.0.0: val join : 'a t -> 'a *) val get_id : 'a t -> id (** @since 5.0.0: val get_id : 'a t -> id *) val self : unit -> id (** @since 5.0.0: val self : unit -> id *) val before_first_spawn : (unit -> unit) -> unit (** @since 5.0.0: val before_first_spawn : (unit -> unit) -> unit *) val at_exit : (unit -> unit) -> unit (** @since 5.0.0: val at_exit : (unit -> unit) -> unit *) val cpu_relax : unit -> unit (** @since 5.0.0: val cpu_relax : unit -> unit *) val is_main_domain : unit -> bool (** @since 5.0.0: val is_main_domain : unit -> bool *) val recommended_domain_count : unit -> int (** @since 5.0.0: val recommended_domain_count : unit -> int *) end ocaml-stdcompat-20~git20240529/stdcompat__either.ml.in000066400000000000000000000023531463722102200225540ustar00rootroot00000000000000@BEGIN_FROM_4_12_0@ include Either @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type ('a, 'b) t = ('a, 'b) Stdcompat__init.either = | Left of 'a | Right of 'b let left v = Left v let right v = Right v let is_left e = match e with | Left _ -> true | Right _ -> false let is_right e = match e with | Left _ -> false | Right _ -> true let find_left e = match e with | Left v -> Some v | Right _ -> None let find_right e = match e with | Left _ -> None | Right v -> Some v let map_left f e = match e with | Left v -> Left (f v) | Right _ as e -> e let map_right f e = match e with | Left _ as e -> e | Right v -> Right (f v) let map ~left ~right e = match e with | Left v -> Left (left v) | Right v -> Right (right v) let fold ~left ~right e = match e with | Left v -> left v | Right v -> right v let iter = fold let for_all = fold let equal ~left ~right e1 e2 = match e1, e2 with | Left v1, Left v2 -> left v1 v2 | Right v1, Right v2 -> right v1 v2 | Left _, Right _ | Right _, Left _ -> false let compare ~left ~right e1 e2 = match e1, e2 with | Left v1, Left v2 -> left v1 v2 | Right v1, Right v2 -> right v1 v2 | Left _, Right _ -> -1 | Right _, Left _ -> 1 @END_BEFORE_4_12_0@ ocaml-stdcompat-20~git20240529/stdcompat__either.mli.in000066400000000000000000000000361463722102200227210ustar00rootroot00000000000000include Stdcompat__either_s.S ocaml-stdcompat-20~git20240529/stdcompat__either_s.mli.in000066400000000000000000000045711463722102200232530ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_12_0@ type ('a, 'b) t = ('a, 'b) Stdcompat__init.either = | Left of 'a | Right of 'b @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type ('a, 'b) t = ('a, 'b) Stdcompat__init.either = | Left of 'a | Right of 'b @END_BEFORE_4_12_0@ (** @since 4.12.0: type ('a, 'b) t = | Left of 'a | Right of 'b *) val left : 'a -> ('a, 'b) t (** @since 4.12.0: val left : 'a -> ('a, 'b) t *) val right : 'b -> ('a, 'b) t (** @since 4.12.0: val right : 'b -> ('a, 'b) t *) val is_left : ('a, 'b) t -> bool (** @since 4.12.0: val is_left : ('a, 'b) t -> bool *) val is_right : ('a, 'b) t -> bool (** @since 4.12.0: val is_right : ('a, 'b) t -> bool *) val find_left : ('a, 'b) t -> 'a option (** @since 4.12.0: val find_left : ('a, 'b) t -> 'a option *) val find_right : ('a, 'b) t -> 'b option (** @since 4.12.0: val find_right : ('a, 'b) t -> 'b option *) val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t (** @since 4.12.0: val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t *) val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t (** @since 4.12.0: val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t *) val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t (** @since 4.12.0: val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t *) val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c (** @since 4.12.0: val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c *) val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit (** @since 4.12.0: val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit *) val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool (** @since 4.12.0: val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool *) val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool (** @since 4.12.0: val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool *) val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int (** @since 4.12.0: val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int *) end ocaml-stdcompat-20~git20240529/stdcompat__ephemeron.ml.in000066400000000000000000000125471463722102200232640ustar00rootroot00000000000000@BEGIN_FROM_5_0_0@ include Ephemeron @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl.statistics end module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl.statistics end let not_implemented () = failwith "Stdcompat.Ephemeron is not implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." module K1 = struct type ('k, 'd) t let make _ = not_implemented () let query _ = not_implemented () module Make (H : Hashtbl.HashedType) = struct include Stdcompat__hashtbl.Make (H) let clean _ = not_implemented () let stats_alive _ = not_implemented () end module MakeSeeded (H : Stdcompat__hashtbl.SeededHashedType) = struct include Stdcompat__hashtbl.MakeSeeded (H) let clean _ = not_implemented () let stats_alive _ = not_implemented () end module Bucket = struct type ('k, 'd) t let make _ = not_implemented () let add _ = not_implemented () let remove _ = not_implemented () let find _ = not_implemented () let length _ = not_implemented () let clear _ = not_implemented () end end module K2 = struct type ('k1, 'k2, 'd) t let make _ = not_implemented () let query _ = not_implemented () module Make (H1 : Hashtbl.HashedType) (H2 : Hashtbl.HashedType) = struct include Stdcompat__hashtbl.Make (struct type t = H1.t * H2.t let equal (x1, x2) (y1, y2) = H1.equal x1 y1 && H2.equal x2 y2 let hash (x, y) = Hashtbl.hash (H1.hash x, H2.hash y) end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end module MakeSeeded (H1 : Stdcompat__hashtbl.SeededHashedType) (H2 : Stdcompat__hashtbl.SeededHashedType) = struct include Stdcompat__hashtbl.MakeSeeded (struct type t = H1.t * H2.t let equal (x1, x2) (y1, y2) = H1.equal x1 y1 && H2.equal x2 y2 let seeded_hash seed (x, y) = Stdcompat__hashtbl.seeded_hash seed (H1.seeded_hash seed x, H2.seeded_hash seed y) end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end module Bucket = struct type ('k1, 'k2, 'd) t let make _ = not_implemented () let add _ = not_implemented () let remove _ = not_implemented () let find _ = not_implemented () let length _ = not_implemented () let clear _ = not_implemented () end end module Kn = struct type ('k, 'd) t let make _ = not_implemented () let query _ = not_implemented () module Make (H : Hashtbl.HashedType) = struct include Stdcompat__hashtbl.Make (struct type t = H.t array let equal x y = let rec check i = i >= Array.length x || H.equal x.(i) y.(i) && check (succ i) in Array.length x = Array.length y && check 0 let hash x = Hashtbl.hash (Array.map H.hash x) end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end module MakeSeeded (H : Stdcompat__hashtbl.SeededHashedType) = struct include Stdcompat__hashtbl.MakeSeeded (struct type t = H.t array let equal x y = let rec check i = i >= Array.length x || H.equal x.(i) y.(i) && check (succ i) in Array.length x = Array.length y && check 0 let seeded_hash seed x = Stdcompat__hashtbl.seeded_hash seed (Array.map (H.seeded_hash seed) x) end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end module Bucket = struct type ('k, 'd) t let make _ = not_implemented () let add _ = not_implemented () let remove _ = not_implemented () let find _ = not_implemented () let length _ = not_implemented () let clear _ = not_implemented () end end @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__ephemeron.mli.in000066400000000000000000000000411463722102200234170ustar00rootroot00000000000000include Stdcompat__ephemeron_s.S ocaml-stdcompat-20~git20240529/stdcompat__ephemeron_s.mli.in000066400000000000000000000264511463722102200237560ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_5_0_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end @END_BEFORE_5_0_0@ (** @since 5.0.0: module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end *) @BEGIN_FROM_5_0_0@ module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end @END_BEFORE_5_0_0@ (** @since 5.0.0: module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Hashtbl.statistics val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Hashtbl.statistics end *) @BEGIN_FROM_5_0_0@ module K1 = Ephemeron.K1 @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module K1 : sig type ('k, 'd) t val make : 'k -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end module MakeSeeded : functor (H : Stdcompat__hashtbl.SeededHashedType) -> sig type key = H.t type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k -> 'd -> unit val remove : ('k, 'd) t -> 'k -> unit val find : ('k, 'd) t -> 'k -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end @END_BEFORE_5_0_0@ (** @since 5.0.0: module K1 = Ephemeron.K1 *) @BEGIN_FROM_5_0_0@ module K2 = Ephemeron.K2 @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module K2 : sig type ('k1, 'k2, 'd) t val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) t val query : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option module Make : functor (H1 : Hashtbl.HashedType) -> functor (H2 : Hashtbl.HashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end module MakeSeeded : functor (H1 : Stdcompat__hashtbl.SeededHashedType) -> functor (H2 : Stdcompat__hashtbl.SeededHashedType) -> sig type key = (H1.t * H2.t) type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end module Bucket : sig type ('k1, 'k2, 'd) t val make : unit -> ('k1, 'k2, 'd) t val add : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd -> unit val remove : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> unit val find : ('k1, 'k2, 'd) t -> 'k1 -> 'k2 -> 'd option val length : ('k1, 'k2, 'd) t -> int val clear : ('k1, 'k2, 'd) t -> unit end end @END_BEFORE_5_0_0@ (** @since 5.0.0: module K2 = Ephemeron.K2 *) @BEGIN_FROM_5_0_0@ module Kn = Ephemeron.Kn @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module Kn : sig type ('k, 'd) t val make : 'k array -> 'd -> ('k, 'd) t val query : ('k, 'd) t -> 'k array -> 'd option module Make : functor (H : Hashtbl.HashedType) -> sig type key = H.t array type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end module MakeSeeded : functor (H : Stdcompat__hashtbl.SeededHashedType) -> sig type key = H.t array type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.statistics val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end module Bucket : sig type ('k, 'd) t val make : unit -> ('k, 'd) t val add : ('k, 'd) t -> 'k array -> 'd -> unit val remove : ('k, 'd) t -> 'k array -> unit val find : ('k, 'd) t -> 'k array -> 'd option val length : ('k, 'd) t -> int val clear : ('k, 'd) t -> unit end end @END_BEFORE_5_0_0@ (** @since 5.0.0: module Kn = Ephemeron.Kn *) end ocaml-stdcompat-20~git20240529/stdcompat__filename.ml.in000066400000000000000000000152041463722102200230530ustar00rootroot00000000000000include Filename @BEGIN_BEFORE_4_08_0@ let chop_suffix_opt ~suffix filename = let len_suffix = String.length suffix in let len_filename = String.length filename in if len_suffix <= len_filename then let len_base = len_filename - len_suffix in let filename_suffix = String.sub filename len_base len_suffix in @BEGIN_WITH_WIN32@ let filename_suffix, suffix = Stdcompat__string.lowercase_ascii filename_suffix, Stdcompat__string.lowercase_ascii suffix in @END_WITH_WIN32@ if filename_suffix = suffix then Some (String.sub filename 0 len_base) else None else None @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_14_0@ let chop_suffix filename suffix = match chop_suffix_opt ~suffix filename with | Some base -> base | None -> invalid_arg "Filename.chop_suffix" @END_BEFORE_4_14_0@ @BEGIN_BEFORE_3_09_0@ let temp_dir_name = @BEGIN_WITH_WIN32@ try Sys.getenv "TEMP" with Not_found -> "." @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ try Sys.getenv "TMPDIR" with Not_found -> "/tmp" @END_WITHOUT_WIN32@ @END_BEFORE_3_09_0@ @BEGIN_BEFORE_4_00_0@ let current_temp_dir_name = ref temp_dir_name let get_temp_dir_name () = !current_temp_dir_name let set_temp_dir_name dir = current_temp_dir_name := dir @END_BEFORE_4_00_0@ @BEGIN_BEFORE_5_1_0@ let prng = lazy (Random.State.make_self_init ()) let temp_file_name temp_dir prefix suffix = let rnd = Random.State.bits (Lazy.force prng) land 0xFFFFFF in concat temp_dir (Printf.sprintf "%s%06x%s" prefix rnd suffix) let rec try_name temp_dir prefix suffix counter f = let name = temp_file_name temp_dir prefix suffix in try name, f name with Sys_error _ as e -> if counter >= 1000 then raise e else try_name temp_dir prefix suffix (succ counter) f @END_BEFORE_5_1_0@ @BEGIN_BEFORE_4_03_0@ let open_temp_file ?(mode = [Open_text]) ?(perms = 0o600) ?(temp_dir = get_temp_dir_name ()) prefix suffix = try_name temp_dir prefix suffix 0 (fun name -> open_out_gen (Open_wronly :: Open_creat :: Open_excl :: mode) perms name) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_00_0@ let temp_file ?(temp_dir = !current_temp_dir_name) prefix suffix = @BEGIN_FROM_3_11_0@ temp_file ~temp_dir prefix suffix @END_FROM_3_11_0@ @BEGIN_BEFORE_3_11_0@ let name, out_channel = open_temp_file ~mode:[] ~temp_dir prefix suffix in close_out out_channel; name @END_BEFORE_3_11_0@ @END_BEFORE_4_00_0@ @BEGIN_BEFORE_5_1_0@ let temp_dir ?(temp_dir = get_temp_dir_name ()) ?(perms = 0o600) prefix suffix = let name, () = try_name temp_dir prefix suffix 0 (fun name -> Stdcompat__sys.mkdir name perms) in name @END_BEFORE_5_1_0@ @BEGIN_BEFORE_3_11_0@ let dir_sep = @BEGIN_WITH_WIN32@ "\\" @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ "/" @END_WITHOUT_WIN32@ @END_BEFORE_3_11_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_WITH_UNIX@ let is_dir_sep c = c = '/' @END_WITH_UNIX@ @BEGIN_WITHOUT_UNIX@ let is_dir_sep c = match c with | '/' | '\\' | ':' -> true | _ -> false @END_WITHOUT_UNIX@ let rec extension_start_from i s = if i < 0 then String.length s else let c = String.unsafe_get s i in if c = '.' then i else if is_dir_sep c then String.length s else extension_start_from (pred i) s let extension_start s = extension_start_from (String.length s - 1) s let extension s = let i = extension_start s in String.sub s i (String.length s - i) let remove_extension s = let i = extension_start s in String.sub s 0 i @END_BEFORE_4_04_0@ @BEGIN_BEFORE_4_10_0@ let null = @BEGIN_WITH_WIN32@ "NUL" @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ "/dev/null" @END_WITHOUT_WIN32@ open Stdcompat__pervasives let quote_redirections buffer quote_string stdin stdout stderr = stdin |> Stdcompat__option.iter (fun f -> Buffer.add_string buffer " <"; quote_string buffer f); stdout |> Stdcompat__option.iter (fun f -> Buffer.add_string buffer " >"; quote_string buffer f); stderr |> Stdcompat__option.iter (fun f -> if stderr = stdout then Buffer.add_string buffer " 2>&1" else ( Buffer.add_string buffer " 2>"; quote_string buffer f )) @BEGIN_WITH_WIN32@ let quote_cmd buffer (s : string) = s |> String.iter (fun c -> (match c with | '(' | ')' | '!' | '^' | '%' | '\"' | '<' | '>' | '&' | '|' -> Buffer.add_char buffer '^' | _ -> ()); Buffer.add_char buffer c) let check_filename (filename : string) = let contains_space = ref false in filename |> String.iter (fun c -> match c with | '\"' | '%' -> failwith ("Filename.quote_command: bad file name " ^ filename) | ' ' -> contains_space := true | _ -> ()); !contains_space let quote s = let buffer = Buffer.create (String.length s + 20) in Buffer.add_char buffer '\"'; let bs_count = ref 0 in let add_bs count = for _ = 1 to count do Buffer.add_char buffer '\\' done in s |> String.iter (fun c -> match c with | '\\' -> incr bs_count | '\"' -> add_bs (2 * !bs_count + 1); bs_count := 0; Buffer.add_char buffer '\"' | _ -> add_bs !bs_count; bs_count := 0; Buffer.add_char buffer c); Buffer.add_char buffer '\"'; add_bs !bs_count; Buffer.contents buffer let quote_cmd_filename buffer (filename : string) = if check_filename filename then ( Buffer.add_char buffer '"'; quote_cmd buffer filename; Buffer.add_char buffer '"') else Buffer.add_string buffer filename let quote_command (command : string) ?(stdin : string option) ?(stdout : string option) ?(stderr : string option) (args : string list) : string = let buffer = Buffer.create 128 in Buffer.add_char buffer '\"'; quote_cmd_filename buffer command; args |> List.iter (fun arg -> Buffer.add_char buffer ' '; quote_cmd buffer (quote arg)); quote_redirections buffer quote_cmd_filename stdin stdout stderr; Buffer.add_char buffer '\"'; Buffer.contents buffer @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ let quote_string buffer (s : string) = Buffer.add_char buffer '\''; s |> String.iter (fun c -> match c with | '\'' -> Buffer.add_string buffer "'\\''" | _ -> Buffer.add_char buffer c); Buffer.add_char buffer '\'' let quote_command (command : string) ?(stdin : string option) ?(stdout : string option) ?(stderr : string option) (args : string list) : string = let buffer = Buffer.create 128 in quote_string buffer command; args |> List.iter (fun arg -> Buffer.add_char buffer ' '; quote_string buffer arg); quote_redirections buffer quote_string stdin stdout stderr; Buffer.contents buffer @END_WITHOUT_WIN32@ @END_BEFORE_4_10_0@ @BEGIN_BEFORE_5_1_0@ @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__filename.mli.in000066400000000000000000000000401463722102200232140ustar00rootroot00000000000000include Stdcompat__filename_s.S ocaml-stdcompat-20~git20240529/stdcompat__filename_s.mli.in000066400000000000000000000046251463722102200235530ustar00rootroot00000000000000module type S = sig val temp_dir : ?temp_dir:string -> ?perms:int -> string -> string -> string (** @since 5.1.0: val temp_dir : ?temp_dir:string -> ?perms:int -> string -> string -> string *) val null : string (** @since 4.10.0: val null : string *) val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string (** @since 4.10.0: val quote_command : string -> ?stdin:string -> ?stdout:string -> ?stderr:string -> string list -> string *) val chop_suffix_opt : suffix:string -> string -> string option (** @since 4.08.0: val chop_suffix_opt : suffix:string -> string -> string option *) val extension : string -> string (** @since 4.04.0: val extension : string -> string *) val remove_extension : string -> string (** @since 4.04.0: val remove_extension : string -> string *) val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) (** @since 4.03.0: val open_temp_file : ?mode:open_flag list -> ?perms:int -> ?temp_dir:string -> string -> string -> (string * out_channel) *) val get_temp_dir_name : unit -> string (** @since 4.00.0: val get_temp_dir_name : unit -> string *) val set_temp_dir_name : string -> unit (** @since 4.00.0: val set_temp_dir_name : string -> unit *) val dir_sep : string (** @since 3.11.0: val dir_sep : string *) val temp_file : ?temp_dir:string -> string -> string -> string (** @since 3.11.0: val temp_file : ?temp_dir:string -> string -> string -> string *) val current_dir_name : string (** Alias for {!Filename.current_dir_name} *) val parent_dir_name : string (** Alias for {!Filename.parent_dir_name} *) val concat : string -> string -> string (** Alias for {!Filename.concat} *) val is_relative : string -> bool (** Alias for {!Filename.is_relative} *) val is_implicit : string -> bool (** Alias for {!Filename.is_implicit} *) val check_suffix : string -> string -> bool (** Alias for {!Filename.check_suffix} *) val chop_suffix : string -> string -> string (** Alias for {!Filename.chop_suffix} *) val chop_extension : string -> string (** Alias for {!Filename.chop_extension} *) val basename : string -> string (** Alias for {!Filename.basename} *) val dirname : string -> string (** Alias for {!Filename.dirname} *) val quote : string -> string (** Alias for {!Filename.quote} *) end ocaml-stdcompat-20~git20240529/stdcompat__float.ml.in000066400000000000000000000554701463722102200224110ustar00rootroot00000000000000@BEGIN_FROM_5_2_0@ include Float @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module Array = struct @BEGIN_FROM_4_08_0@ include Float.Array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type t = Stdcompat__init.floatarray include Stdcompat__array.Floatarray let unsafe_fill array offset len v = for i = offset to offset + len - 1 do unsafe_set array i v done let unsafe_blit src src_offset dst dst_offset len = for i = 0 to len - 1 do unsafe_set dst (dst_offset + i) (unsafe_get src (src_offset + i)) done let make len v = let result = create len in unsafe_fill result 0 len v; result let init len f = let result = create len in for i = 0 to len - 1 do unsafe_set result i (f i) done; result let append a1 a2 = let l1 = length a1 in let l2 = length a2 in let result = create (l1 + l2) in unsafe_blit a1 0 result 0 l1; unsafe_blit a2 0 result l1 l2; result let concat l = let len = List.fold_left (fun acc a -> acc + length a) 0 l in let result = create len in let rec loop l i = match l with | [] -> () | hd :: tl -> let len = length hd in unsafe_blit hd 0 result i len; loop tl (i + len) in loop l 0; result let check a offset len msg = if offset < 0 || len < 0 || offset + len < 0 || offset + len > length a then failwith msg let sub a offset len = check a offset len "Float.Array.sub"; let result = create len in unsafe_blit a offset result 0 len; result let copy a = let len = length a in let result = create len in unsafe_blit a 0 result 0 len; result let fill a offset len v = check a offset len "Float.Array.fill"; unsafe_fill a offset len v let blit src src_offset dst dst_offset len = check src src_offset len "Float.Array.blit"; check dst dst_offset len "Float.Array.blit"; unsafe_blit dst src_offset dst dst_offset len let to_list a = Stdcompat__list.init (length a) (unsafe_get a) let of_list l = let result = create (List.length l) in let rec fill i l = match l with | [] -> result | hd :: tl -> unsafe_set result i hd; fill (succ i) tl in fill 0 l let iter f a = for i = 0 to length a - 1 do f (unsafe_get a i) done let iteri f a = for i = 0 to length a - 1 do f i (unsafe_get a i) done let map f a = let len = length a in let result = create len in for i = 0 to len - 1 do unsafe_set result i (f (unsafe_get a i)) done; result let mapi f a = let len = length a in let result = create len in for i = 0 to len - 1 do unsafe_set result i (f i (unsafe_get a i)) done; result let fold_left f acc a = let len = length a in let rec aux i acc = if i < len then aux (succ i) (f acc (unsafe_get a i)) else acc in aux 0 acc let fold_right f a acc = let len = length a in let rec aux i acc = if i > 0 then let j = pred i in aux j (f (unsafe_get a j) acc) else acc in aux len acc let iter2 f a b = let len = length a in if len <> length b then failwith "Float.Array.iter2"; for i = 0 to len - 1 do f (unsafe_get a i) (unsafe_get b i) done let map2 f a b = let len = length a in if len <> length b then failwith "Float.Array.iter2"; let result = create len in for i = 0 to len - 1 do unsafe_set result i (f (unsafe_get a i) (unsafe_get b i)) done; result let for_all f a = let len = length a in let rec aux i = i >= len || f (unsafe_get a i) && aux (succ i) in aux 0 let exists f a = let len = length a in let rec aux i = i < len && (f (unsafe_get a i) || aux (succ i)) in aux 0 let mem x a = exists (fun y -> compare x y = 0) a let mem_ieee x a = exists (( = ) x) a let sort _p _a = failwith "unimplemented" let stable_sort = sort let fast_sort = sort let to_seq a = let rec aux i () = if i < length a then let x = unsafe_get a i in Stdcompat__seq.Cons (x, aux (i + 1)) else Stdcompat__seq.Nil in aux 0 let to_seqi a = let rec aux i () = if i < length a then let x = unsafe_get a i in Stdcompat__seq.Cons ((i, x), aux (i + 1)) else Stdcompat__seq.Nil in aux 0 let of_rev_list l = let len = List.length l in let result = create len in let rec fill i l = match l with | [] -> result | hd :: tl -> unsafe_set result i hd; fill (pred i) tl in fill (len - 1) l let of_seq i = let l = Stdcompat__seq.fold_left (fun acc x -> x :: acc) [] i in of_rev_list l let map_to_array f a = Array.init (length a) (fun i -> f (unsafe_get a i)) let map_from_array f a = init (Array.length a) (fun i -> f (Array.unsafe_get a i)) @END_BEFORE_4_08_0@ @BEGIN_BEFORE_5_1_0@ let map_inplace f array = for i = 0 to length array - 1 do unsafe_set array i (f (unsafe_get array i)) done let mapi_inplace f array = for i = 0 to length array - 1 do unsafe_set array i (f i (unsafe_get array i)) done let rec find_opt_from index f array = if index < length array then let v = unsafe_get array index in if f v then Some v else find_opt_from (succ index) f array else None let find_opt f array = find_opt_from 0 f array let rec find_index_from index p array = if index < length array then if p (unsafe_get array index) then Some index else find_index_from (succ index) p array else None let find_index p array = find_index_from 0 p array let rec find_map_from index f array = if index < length array then match f (unsafe_get array index) with | None -> find_map_from (succ index) f array | some -> some else None let find_map f array = find_map_from 0 f array let rec find_mapi_from index f array = if index < length array then match f index (unsafe_get array index) with | None -> find_mapi_from (succ index) f array | some -> some else None let find_mapi f array = find_mapi_from 0 f array @END_BEFORE_5_1_0@ let make_matrix m n x = Array.init m (fun _ -> make n x) let init_matrix m n f = Array.init m (fun i -> init n (fun j -> f i j)) let shuffle ~rand array = for i = length array - 1 downto 0 do let j = rand (i + 1) in let tmp = unsafe_get array i in unsafe_set array i (get array j); unsafe_set array j tmp done end module ArrayLabels = struct @BEGIN_FROM_4_08_0@ include Float.ArrayLabels @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ include Float.Array let init i ~f = init i f let sub a ~pos ~len = sub a pos len let fill a ~pos ~len v = fill a pos len v let blit ~src ~src_pos ~dst ~dst_pos ~len = blit src src_pos dst dst_pos len let iter ~f a = iter f a let iteri ~f a = iteri f a let map ~f a = map f a let mapi ~f a = mapi f a let fold_left ~f ~init a = fold_left f init a let fold_right ~f a ~init = fold_right f a init let iter2 ~f a = iter2 f a let map2 ~f a = map2 f a let for_all ~f a = for_all f a let exists ~f a = exists f a let mem v ~set = mem v set let mem_ieee v ~set = mem_ieee v set let sort ~cmp a = sort cmp a let stable_sort ~cmp a = stable_sort cmp a let fast_sort ~cmp a = fast_sort cmp a let map_to_array ~f a = map_to_array f a let map_from_array ~f a = map_from_array f a @END_BEFORE_4_08_0@ @BEGIN_BEFORE_5_1_0@ let map_inplace ~f a = Array.map_inplace f a let mapi_inplace ~f a = Array.mapi_inplace f a let find_opt ~f a = Array.find_opt f a let find_index ~f a = Array.find_index f a let find_map ~f a = Array.find_map f a let find_mapi ~f a = Array.find_mapi f a @END_BEFORE_5_1_0@ let make_matrix ~dimx ~dimy v = Array.make_matrix dimx dimy v let init_matrix ~dimx ~dimy ~f = Array.init_matrix dimx dimy f let shuffle ~rand a = Array.shuffle rand a end @BEGIN_FROM_4_07_0@ include (Float : module type of Float with module Array := Array and module ArrayLabels := ArrayLabels) @END_FROM_4_07_0@ @END_BEFORE_5_2_0@ @BEGIN_BEFORE_4_07_0@ type fpclass = Pervasives.fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan (** @since 4.07.0: type fpclass = Pervasives.fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan *) type t = float let infinity = Pervasives.infinity let neg_infinity = Pervasives.neg_infinity let nan = Pervasives.nan @BEGIN_FROM_4_03_0@ let pi = 0x1.921fb54442d18p+1 @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ let pi = 4. *. atan 1. @END_BEFORE_4_03_0@ let max_float = Pervasives.max_float let min_float = Pervasives.min_float let epsilon = Pervasives.epsilon_float let of_string_opt = Stdcompat__pervasives.float_of_string_opt let to_string = Pervasives.string_of_float external compare : float -> float -> int = "%compare" let equal x y = compare x y = 0 let hash = Hashtbl.hash @BEGIN_FROM_4_03_0@ external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_00_0@ external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ let hypot = Stdcompat__pervasives.hypot @END_BEFORE_4_00_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_12_0@ external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ let expm1 = Stdcompat__pervasives.expm1 @END_BEFORE_3_12_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_12_0@ external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ let log1p = Stdcompat__pervasives.log1p @END_BEFORE_3_12_0@ @END_BEFORE_4_03_0@ external neg : float -> float = "%negfloat" external add : float -> float -> float = "%addfloat" external sub : float -> float -> float = "%subfloat" external mul : float -> float -> float = "%mulfloat" external div : float -> float -> float = "%divfloat" @BEGIN_FROM_4_03_0@ external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external rem : float -> float -> float = "caml_fmod_float" "fmod" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external rem : float -> float -> float = "fmod_float" "fmod" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ external abs : float -> float = "%absfloat" external of_int : int -> float = "%floatofint" external to_int : float -> int = "%intoffloat" @BEGIN_FROM_3_08_0@ external of_string : string -> float = "caml_float_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_string : string -> float = "float_of_string" @END_BEFORE_3_08_0@ @BEGIN_FROM_4_03_0@ external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external classify_float : float -> fpclass = "caml_classify_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external classify_float : float -> fpclass = "classify_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external pow : float -> float -> float = "caml_power_float" "pow" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external pow : float -> float -> float = "power_float" "pow" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sqrt : float -> float = "sqrt_float" "sqrt" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external exp : float -> float = "caml_exp_float" "exp" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external exp : float -> float = "exp_float" "exp" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external log : float -> float = "caml_log_float" "log" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external log : float -> float = "log_float" "log" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external log10 : float -> float = "caml_log10_float" "log10" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external log10 : float -> float = "log10_float" "log10" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external cos : float -> float = "caml_cos_float" "cos" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external cos : float -> float = "cos_float" "cos" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sin : float -> float = "caml_sin_float" "sin" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sin : float -> float = "sin_float" "sin" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external tan : float -> float = "caml_tan_float" "tan" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external tan : float -> float = "tan_float" "tan" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external acos : float -> float = "caml_acos_float" "acos" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external acos : float -> float = "acos_float" "acos" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external asin : float -> float = "caml_asin_float" "asin" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external asin : float -> float = "asin_float" "asin" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external atan : float -> float = "caml_atan_float" "atan" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external atan : float -> float = "atan_float" "atan" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external atan2 : float -> float -> float = "atan2_float" "atan2" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external cosh : float -> float = "caml_cosh_float" "cosh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external cosh : float -> float = "cosh_float" "cosh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sinh : float -> float = "caml_sinh_float" "sinh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sinh : float -> float = "sinh_float" "sinh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external tanh : float -> float = "caml_tanh_float" "tanh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external tanh : float -> float = "tanh_float" "tanh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ceil : float -> float = "caml_ceil_float" "ceil" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external ceil : float -> float = "ceil_float" "ceil" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_4_03_0@ external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external floor : float -> float = "caml_floor_float" "floor" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external floor : float -> float = "floor_float" "floor" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external frexp : float -> (float * int) = "caml_frexp_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external frexp : float -> (float * int) = "frexp_float" @END_BEFORE_3_08_0@ @BEGIN_FROM_4_03_0@ external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ldexp : float -> int -> float = "caml_ldexp_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external ldexp : float -> int -> float = "ldexp_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external modf : float -> (float * float) = "caml_modf_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external modf : float -> (float * float) = "modf_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_08_0@ let sign_of_bits bits = not (Stdcompat__int64.equal (Int64.shift_right_logical bits 63) Int64.zero) let sign_bit x = sign_of_bits (Int64.bits_of_float x) let is_nan (x : float) = x <> x let is_infinite x = 1. /. x = 0. let is_finite x = x -. x = 0. let trunc x = if sign_bit x then ceil x else floor x let is_integer x = x = trunc x && is_finite x let round x = if is_finite x then let ceil = ceil x in let floor = floor x in let o = compare (x -. floor) (ceil -. x) in if o < 0 then floor else if o > 0 then ceil else if sign_bit x then floor else ceil else x let min_max_num x y = if is_nan x then (y, y) else if is_nan y then (x, x) else if x <= y && (sign_bit x || not (sign_bit y)) then (x, y) else (y, x) let max_num x y = if is_nan x then y else if is_nan y then x else if x <= y && (sign_bit x || not (sign_bit y)) then y else x let min_num x y = if is_nan x then y else if is_nan y then x else if x <= y && (sign_bit x || not (sign_bit y)) then x else y let min_max x y = if is_nan x then (x, x) else if is_nan y then (y, y) else if x <= y && (sign_bit x || not (sign_bit y)) then (x, y) else (y, x) let max x y = if is_nan x then x else if is_nan y then y else if x <= y && (sign_bit x || not (sign_bit y)) then y else x let min x y = if is_nan x then x else if is_nan y then y else if x <= y && (sign_bit x || not (sign_bit y)) then x else y @BEGIN_FROM_4_03_0@ external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_00_0@ external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ let copy_sign = Stdcompat__pervasives.copysign @END_BEFORE_4_00_0@ @END_BEFORE_4_03_0@ let pred_ x = let bits = Int64.bits_of_float x in if is_finite x then let bits' = if sign_of_bits bits then Int64.succ bits else Int64.pred bits in Int64.float_of_bits bits' else if sign_of_bits bits then x else Int64.float_of_bits (Int64.pred bits) let succ_ x = let bits = Int64.bits_of_float x in if is_finite x then let bits' = if sign_of_bits bits then Int64.pred bits else Int64.succ bits in Int64.float_of_bits bits' else if sign_of_bits bits then Int64.float_of_bits (Int64.pred bits) else x let next_after x y = if is_nan x || is_nan y then nan else let o = compare x y in if o < 0 then succ_ x else if o > 0 then pred_ x else y let pred x = if is_nan x then x else pred_ x let succ x = if is_nan x then x else succ_ x let fma x y z = x *. y +. z let minus_one = -1. let one = 1. let zero = 0. @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_13_0@ let cbrt x = let res = exp ((1. /. 3.) *. log (abs x)) in if x >= 0. then res else -. res let log2e = log 2. let log2 x = log x /. log2e let exp2 x = pow 2. x let acosh x = log (x +. sqrt (x *. x -. 1.)) let asinh x = log (x +. sqrt (x *. x +. 1.)) let atanh x = 0.5 *. log ((1. +. x) /. (1. -. x)) let erf x = (* from ocaml source floats.c, based on formula 7.1.26 from the "Handbook of Mathematical Functions" by Abramowitz and Stegun. *) let a1 = 0.254829592 and a2 = -0.284496736 and a3 = 1.421413741 and a4 = -1.453152027 and a5 = 1.061405429 and p = 0.3275911 in let x' = abs x in let t = 1. /. (1. +. p *. x') in let y = 1. -. ((((a5 *. t +. a4) *. t +. a3) *. t +. a2) *. t +. a1) *. t *. exp (-. x' *. x') in if x >= 0. then y else -. y let erfc x = 1. -. erf x @END_BEFORE_4_13_0@ @BEGIN_BEFORE_5_1_0@ let signaling_nan = nan let quiet_nan = nan let seeded_hash = Stdcompat__hashtbl.seeded_hash @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__float.mli.in000066400000000000000000000000351463722102200225450ustar00rootroot00000000000000include Stdcompat__float_s.S ocaml-stdcompat-20~git20240529/stdcompat__float_s.mli.in000066400000000000000000000740051463722102200230770ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_07_0@ type fpclass = Stdlib.fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ type fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan @END_BEFORE_4_07_0@ (** @since 4.07.0: type fpclass = Stdlib.fpclass = | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan *) @BEGIN_FROM_4_07_0@ type t = float @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ type t = float @END_BEFORE_4_07_0@ (** @since 4.07.0: type t = float *) @BEGIN_FROM_5_2_0@ module Array = Float.Array @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ @BEGIN_FROM_4_06_0@ module Array : sig type t = Stdcompat__init.floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val make_matrix : int -> int -> float -> t array val init_matrix : int -> int -> (int -> int -> float) -> t array val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val map_inplace : (float -> float) -> t -> unit val mapi : (int -> float -> float) -> t -> t val mapi_inplace : (int -> float -> float) -> t -> unit val fold_left : ('acc -> float -> 'acc) -> 'acc -> t -> 'acc val fold_right : (float -> 'acc -> 'acc) -> t -> 'acc -> 'acc val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val find_opt : (float -> bool) -> t -> float option val find_index : (float -> bool) -> t -> int option val find_map : (float -> 'a option) -> t -> 'a option val find_mapi : (int -> float -> 'a option) -> t -> 'a option val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val shuffle : rand:(int -> int) -> t -> unit val to_seq : t -> float Stdcompat__seq.t val to_seqi : t -> (int * float) Stdcompat__seq.t val of_seq : float Stdcompat__seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ module Array : sig type t = Stdcompat__init.floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> (int -> float) -> t val make_matrix : int -> int -> float -> t array val init_matrix : int -> int -> (int -> int -> float) -> t array val append : t -> t -> t val concat : t list -> t val sub : t -> int -> int -> t val copy : t -> t val fill : t -> int -> int -> float -> unit val blit : t -> int -> t -> int -> int -> unit val to_list : t -> float list val of_list : float list -> t val iter : (float -> unit) -> t -> unit val iteri : (int -> float -> unit) -> t -> unit val map : (float -> float) -> t -> t val map_inplace : (float -> float) -> t -> unit val mapi : (int -> float -> float) -> t -> t val mapi_inplace : (int -> float -> float) -> t -> unit val fold_left : ('acc -> float -> 'acc) -> 'acc -> t -> 'acc val fold_right : (float -> 'acc -> 'acc) -> t -> 'acc -> 'acc val iter2 : (float -> float -> unit) -> t -> t -> unit val map2 : (float -> float -> float) -> t -> t -> t val for_all : (float -> bool) -> t -> bool val exists : (float -> bool) -> t -> bool val mem : float -> t -> bool val mem_ieee : float -> t -> bool val find_opt : (float -> bool) -> t -> float option val find_index : (float -> bool) -> t -> int option val find_map : (float -> 'a option) -> t -> 'a option val find_mapi : (int -> float -> 'a option) -> t -> 'a option val sort : (float -> float -> int) -> t -> unit val stable_sort : (float -> float -> int) -> t -> unit val fast_sort : (float -> float -> int) -> t -> unit val shuffle : rand:(int -> int) -> t -> unit val to_seq : t -> float Stdcompat__seq.t val to_seqi : t -> (int * float) Stdcompat__seq.t val of_seq : float Stdcompat__seq.t -> t val map_to_array : (float -> 'a) -> t -> 'a array val map_from_array : ('a -> float) -> 'a array -> t val unsafe_get : t -> int -> float val unsafe_set : t -> int -> float -> unit end @END_BEFORE_4_06_0@ @END_BEFORE_5_2_0@ (** @since 5.2.0: module Array = Float.Array *) @BEGIN_FROM_5_2_0@ module ArrayLabels = Float.ArrayLabels @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ @BEGIN_FROM_4_06_0@ module ArrayLabels : sig type t = Stdcompat__init.floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val make_matrix : dimx:int -> dimy:int -> float -> t array val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> float) -> t array val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val map_inplace : f:(float -> float) -> t -> unit val mapi : f:(int -> float -> float) -> t -> t val mapi_inplace : f:(int -> float -> float) -> t -> unit val fold_left : f:('acc -> float -> 'acc) -> init:'acc -> t -> 'acc val fold_right : f:(float -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val find_opt : f:(float -> bool) -> t -> float option val find_index : f:(float -> bool) -> t -> int option val find_map : f:(float -> 'a option) -> t -> 'a option val find_mapi : f:(int -> float -> 'a option) -> t -> 'a option val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val shuffle : rand:(int -> int) -> t -> unit val to_seq : t -> float Stdcompat__seq.t val to_seqi : t -> (int * float) Stdcompat__seq.t val of_seq : float Stdcompat__seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get" external unsafe_set : floatarray -> int -> float -> unit = "%floatarray_unsafe_set" end @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ module ArrayLabels : sig type t = Stdcompat__init.floatarray val length : t -> int val get : t -> int -> float val set : t -> int -> float -> unit val make : int -> float -> t val create : int -> t val init : int -> f:(int -> float) -> t val make_matrix : dimx:int -> dimy:int -> float -> t array val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> float) -> t array val append : t -> t -> t val concat : t list -> t val sub : t -> pos:int -> len:int -> t val copy : t -> t val fill : t -> pos:int -> len:int -> float -> unit val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit val to_list : t -> float list val of_list : float list -> t val iter : f:(float -> unit) -> t -> unit val iteri : f:(int -> float -> unit) -> t -> unit val map : f:(float -> float) -> t -> t val map_inplace : f:(float -> float) -> t -> unit val mapi : f:(int -> float -> float) -> t -> t val mapi_inplace : f:(int -> float -> float) -> t -> unit val fold_left : f:('acc -> float -> 'acc) -> init:'acc -> t -> 'acc val fold_right : f:(float -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val iter2 : f:(float -> float -> unit) -> t -> t -> unit val map2 : f:(float -> float -> float) -> t -> t -> t val for_all : f:(float -> bool) -> t -> bool val exists : f:(float -> bool) -> t -> bool val mem : float -> set:t -> bool val mem_ieee : float -> set:t -> bool val find_opt : f:(float -> bool) -> t -> float option val find_index : f:(float -> bool) -> t -> int option val find_map : f:(float -> 'a option) -> t -> 'a option val find_mapi : f:(int -> float -> 'a option) -> t -> 'a option val sort : cmp:(float -> float -> int) -> t -> unit val stable_sort : cmp:(float -> float -> int) -> t -> unit val fast_sort : cmp:(float -> float -> int) -> t -> unit val shuffle : rand:(int -> int) -> t -> unit val to_seq : t -> float Stdcompat__seq.t val to_seqi : t -> (int * float) Stdcompat__seq.t val of_seq : float Stdcompat__seq.t -> t val map_to_array : f:(float -> 'a) -> t -> 'a array val map_from_array : f:('a -> float) -> 'a array -> t val unsafe_get : t -> int -> float val unsafe_set : t -> int -> float -> unit end @END_BEFORE_4_06_0@ @END_BEFORE_5_2_0@ (** @since 5.2.0: module ArrayLabels = Float.ArrayLabels *) val signaling_nan : float (** @since 5.1.0: val signaling_nan : float *) val quiet_nan : float (** @since 5.1.0: val quiet_nan : float *) val seeded_hash : int -> t -> int (** @since 5.1.0: val seeded_hash : int -> t -> int *) @BEGIN_FROM_4_13_0@ external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val cbrt : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external cbrt : float -> float = "caml_cbrt_float" "caml_cbrt"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_13_0@ external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val exp2 : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external exp2 : float -> float = "caml_exp2_float" "caml_exp2"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_13_0@ external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val log2 : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external log2 : float -> float = "caml_log2_float" "caml_log2"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_13_0@ external acosh : float -> float = "caml_acosh_float" "caml_acosh"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val acosh : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external acosh : float -> float = "caml_acosh_float" "caml_acosh" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_13_0@ external asinh : float -> float = "caml_asinh_float" "caml_asinh"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val asinh : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external asinh : float -> float = "caml_asinh_float" "caml_asinh" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_13_0@ external atanh : float -> float = "caml_atanh_float" "caml_atanh"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val atanh : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external atanh : float -> float = "caml_atanh_float" "caml_atanh" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_13_0@ external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val erf : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external erf : float -> float = "caml_erf_float" "caml_erf"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_13_0@ external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val erfc : float -> float @END_BEFORE_4_13_0@ (** @since 4.13.0: external erfc : float -> float = "caml_erfc_float" "caml_erfc"[@@unboxed ] [@@noalloc ] *) val zero : float (** @since 4.08.0: val zero : float *) val one : float (** @since 4.08.0: val one : float *) val minus_one : float (** @since 4.08.0: val minus_one : float *) @BEGIN_FROM_4_08_0@ external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma" [@@unboxed ][@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val fma : float -> float -> float -> float @END_BEFORE_4_08_0@ (** @since 4.08.0: external fma : float -> float -> float -> float = "caml_fma_float" "caml_fma"[@@unboxed ] [@@noalloc ] *) val succ : float -> float (** @since 4.08.0: val succ : float -> float *) val pred : float -> float (** @since 4.08.0: val pred : float -> float *) val is_finite : float -> bool (** @since 4.08.0: val is_finite : float -> bool *) val is_infinite : float -> bool (** @since 4.08.0: val is_infinite : float -> bool *) val is_nan : float -> bool (** @since 4.08.0: val is_nan : float -> bool *) val is_integer : float -> bool (** @since 4.08.0: val is_integer : float -> bool *) @BEGIN_FROM_4_08_0@ external trunc : float -> float = "caml_trunc_float" "caml_trunc"[@@unboxed ] [@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val trunc : float -> float @END_BEFORE_4_08_0@ (** @since 4.08.0: external trunc : float -> float = "caml_trunc_float" "caml_trunc" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_08_0@ external round : float -> float = "caml_round_float" "caml_round"[@@unboxed ] [@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val round : float -> float @END_BEFORE_4_08_0@ (** @since 4.08.0: external round : float -> float = "caml_round_float" "caml_round" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_08_0@ external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter"[@@unboxed ] [@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val next_after : float -> float -> float @END_BEFORE_4_08_0@ (** @since 4.08.0: external next_after : float -> float -> float = "caml_nextafter_float" "caml_nextafter" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_03_0@ external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_00_0@ external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val copy_sign : float -> float -> float @END_BEFORE_4_00_0@ @END_BEFORE_4_03_0@ (** @since 4.08.0: external copy_sign : float -> float -> float = "caml_copysign_float" "caml_copysign" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_08_0@ external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit"[@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val sign_bit : float -> bool @END_BEFORE_4_08_0@ (** @since 4.08.0: external sign_bit : ((float)[@unboxed ]) -> bool = "caml_signbit_float" "caml_signbit" [@@noalloc ] *) val min : t -> t -> t (** @since 4.08.0: val min : t -> t -> t *) val max : float -> float -> float (** @since 4.08.0: val max : float -> float -> float *) val min_max : float -> float -> (float * float) (** @since 4.08.0: val min_max : float -> float -> (float * float) *) val min_num : t -> t -> t (** @since 4.08.0: val min_num : t -> t -> t *) val max_num : t -> t -> t (** @since 4.08.0: val max_num : t -> t -> t *) val min_max_num : float -> float -> (float * float) (** @since 4.08.0: val min_max_num : float -> float -> (float * float) *) external neg : float -> float = "%negfloat" (** @since 4.07.0: external neg : float -> float = "%negfloat" *) external add : float -> float -> float = "%addfloat" (** @since 4.07.0: external add : float -> float -> float = "%addfloat" *) external sub : float -> float -> float = "%subfloat" (** @since 4.07.0: external sub : float -> float -> float = "%subfloat" *) external mul : float -> float -> float = "%mulfloat" (** @since 4.07.0: external mul : float -> float -> float = "%mulfloat" *) external div : float -> float -> float = "%divfloat" (** @since 4.07.0: external div : float -> float -> float = "%divfloat" *) @BEGIN_FROM_4_03_0@ external rem : float -> float -> float = "caml_fmod_float" "fmod"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external rem : float -> float -> float = "caml_fmod_float" "fmod" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external rem : float -> float -> float = "fmod_float" "fmod" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external rem : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] *) external abs : float -> float = "%absfloat" (** @since 4.07.0: external abs : float -> float = "%absfloat" *) val infinity : float (** @since 4.07.0: val infinity : float *) val neg_infinity : float (** @since 4.07.0: val neg_infinity : float *) val nan : float (** @since 4.07.0: val nan : float *) val pi : float (** @since 4.07.0: val pi : float *) val max_float : float (** @since 4.07.0: val max_float : float *) val min_float : float (** @since 4.07.0: val min_float : float *) val epsilon : float (** @since 4.07.0: val epsilon : float *) external of_int : int -> float = "%floatofint" (** @since 4.07.0: external of_int : int -> float = "%floatofint" *) external to_int : float -> int = "%intoffloat" (** @since 4.07.0: external to_int : float -> int = "%intoffloat" *) @BEGIN_FROM_3_08_0@ external of_string : string -> float = "caml_float_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_string : string -> float = "float_of_string" @END_BEFORE_3_08_0@ (** @since 4.07.0: external of_string : string -> float = "caml_float_of_string" *) val of_string_opt : string -> float option (** @since 4.07.0: val of_string_opt : string -> float option *) val to_string : float -> string (** @since 4.07.0: val to_string : float -> string *) @BEGIN_FROM_4_03_0@ external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external classify_float : float -> fpclass = "caml_classify_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external classify_float : float -> fpclass = "classify_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] *) @BEGIN_FROM_4_03_0@ external pow : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external pow : float -> float -> float = "caml_power_float" "pow" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external pow : float -> float -> float = "power_float" "pow" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external pow : float -> float -> float = "caml_power_float" "pow" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_03_0@ external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sqrt : float -> float = "sqrt_float" "sqrt" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external exp : float -> float = "caml_exp_float" "exp" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external exp : float -> float = "exp_float" "exp" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external log : float -> float = "caml_log_float" "log" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external log : float -> float = "log_float" "log" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external log : float -> float = "caml_log_float" "log"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external log10 : float -> float = "caml_log10_float" "log10" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external log10 : float -> float = "log10_float" "log10" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_12_0@ external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ val expm1 : float -> float @END_BEFORE_3_12_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external expm1 : float -> float = "caml_expm1_float" "caml_expm1" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_03_0@ external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_12_0@ external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ val log1p : float -> float @END_BEFORE_3_12_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external log1p : float -> float = "caml_log1p_float" "caml_log1p" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_03_0@ external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external cos : float -> float = "caml_cos_float" "cos" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external cos : float -> float = "cos_float" "cos" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sin : float -> float = "caml_sin_float" "sin" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sin : float -> float = "sin_float" "sin" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external tan : float -> float = "caml_tan_float" "tan" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external tan : float -> float = "tan_float" "tan" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external acos : float -> float = "caml_acos_float" "acos" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external acos : float -> float = "acos_float" "acos" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external asin : float -> float = "caml_asin_float" "asin" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external asin : float -> float = "asin_float" "asin" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external atan : float -> float = "caml_atan_float" "atan" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external atan : float -> float = "atan_float" "atan" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external atan2 : float -> float -> float = "atan2_float" "atan2" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] *) @BEGIN_FROM_4_03_0@ external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_00_0@ external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val hypot : float -> float -> float @END_BEFORE_4_00_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external cosh : float -> float = "caml_cosh_float" "cosh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external cosh : float -> float = "cosh_float" "cosh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sinh : float -> float = "caml_sinh_float" "sinh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sinh : float -> float = "sinh_float" "sinh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external tanh : float -> float = "caml_tanh_float" "tanh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external tanh : float -> float = "tanh_float" "tanh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ceil : float -> float = "caml_ceil_float" "ceil" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external ceil : float -> float = "ceil_float" "ceil" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_4_03_0@ external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external floor : float -> float = "caml_floor_float" "floor" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external floor : float -> float = "floor_float" "floor" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] *) @BEGIN_FROM_3_08_0@ external frexp : float -> (float * int) = "caml_frexp_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external frexp : float -> (float * int) = "frexp_float" @END_BEFORE_3_08_0@ (** @since 4.07.0: external frexp : float -> (float * int) = "caml_frexp_float" *) @BEGIN_FROM_4_03_0@ external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ldexp : float -> int -> float = "caml_ldexp_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ val ldexp : float -> int -> float @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.07.0: external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] *) @BEGIN_FROM_3_08_0@ external modf : float -> (float * float) = "caml_modf_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external modf : float -> (float * float) = "modf_float" @END_BEFORE_3_08_0@ (** @since 4.07.0: external modf : float -> (float * float) = "caml_modf_float" *) val compare : t -> t -> int (** @since 4.07.0: val compare : t -> t -> int *) val equal : t -> t -> bool (** @since 4.07.0: val equal : t -> t -> bool *) val hash : t -> int (** @since 4.07.0: val hash : t -> int *) end ocaml-stdcompat-20~git20240529/stdcompat__format.ml.in000066400000000000000000000166461463722102200225760ustar00rootroot00000000000000@BEGIN_FROM_4_06_0@ include Format @END_FROM_4_06_0@ @BEGIN_BEFORE_5_2_0@ let pp_print_nothing _fmt () = () let pp_infinity = 1000000010 @END_BEFORE_5_2_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_01_0@ include (Format : module type of struct include Format end with type formatter_out_functions := Format.formatter_out_functions) @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ include Format @END_BEFORE_4_01_0@ type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } @BEGIN_FROM_4_01_0@ let downgrade_formatter_out_functions functions = let { out_string; out_flush; out_newline; out_spaces; out_indent = _ } = functions in { Format.out_string; out_flush; out_newline; out_spaces } let upgrade_formatter_out_functions functions = let { Format.out_string; out_flush; out_newline; out_spaces } = functions in let out_indent _ = failwith "Not implemented." in { out_string; out_flush; out_newline; out_spaces; out_indent } let pp_set_formatter_out_functions fmt functions = Format.pp_set_formatter_out_functions fmt (downgrade_formatter_out_functions functions) let set_formatter_out_functions functions = Format.set_formatter_out_functions (downgrade_formatter_out_functions functions) let pp_get_formatter_out_functions fmt () = upgrade_formatter_out_functions (Format.pp_get_formatter_out_functions fmt ()) let get_formatter_out_functions () = upgrade_formatter_out_functions (Format.get_formatter_out_functions ()) @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ let pp_set_formatter_out_functions _ = failwith "Not implemented." let set_formatter_out_functions _ = failwith "Not implemented." let pp_get_formatter_out_functions _ = failwith "Not implemented." let get_formatter_out_functions _ = failwith "Not implemented." @END_BEFORE_4_01_0@ @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_01_0@ let asprintf _ = failwith "Not implemented." @END_BEFORE_4_01_0@ @BEGIN_BEFORE_4_06_0@ type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_06_0@ type symbolic_output_buffer @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_08_0@ let pp_print_option ?none some formatter value = match value with | None -> begin match none with | None -> () | Some none -> none formatter () end | Some value -> some formatter value let pp_print_result ~ok ~error formatter value = match value with | Stdcompat__result.Ok v -> ok formatter v | Stdcompat__result.Error e -> error formatter e let dprintf _ = failwith "Not implemented." let kdprintf _ = failwith "Not implemented." let get_formatter_stag_functions _ = failwith "Not implemented." let pp_get_formatter_stag_functions _ = failwith "Not implemented." let set_formatter_stag_functions _ = failwith "Not implemented." let pp_set_formatter_stag_functions _ = failwith "Not implemented." let close_stag _ = failwith "Not implemented." let pp_close_stag _ = failwith "Not implemented." let open_stag _ = failwith "Not implemented." let pp_open_stag _ = failwith "Not implemented." let get_geometry _ = failwith "Not implemented." let pp_get_geometry _ = failwith "Not implemented." let set_geometry ~max_indent:_ ~margin:_ = failwith "Not implemented." let pp_set_geometry _ ~max_indent:_ ~margin:_ = failwith "Not implemented." let safe_set_geometry ~max_indent:_ ~margin:_ = failwith "Not implemented." let pp_safe_set_geometry _ ~max_indent:_ ~margin:_ = failwith "Not implemented." let check_geometry _ = failwith "Not implemented." let pp_print_custom_break _ = failwith "Not implemented." @BEGIN_FROM_4_02_0@ type stag = .. @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type stag @END_BEFORE_4_02_0@ type geometry = { max_indent: int ; margin: int } type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_06_0@ let formatter_of_out_functions _ = failwith "Not implemented." let make_symbolic_output_buffer _ = failwith "Not implemented." let clear_symbolic_output_buffer _ = failwith "Not implemented." let get_symbolic_output_buffer _ = failwith "Not implemented." let flush_symbolic_output_buffer _ = failwith "Not implemented." let add_symbolic_output_item _ = failwith "Not implemented." let formatter_of_symbolic_output_buffer _ = failwith "Not implemented." @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_03_0@ let kasprintf _ = failwith "Not implemented." @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_02_0@ let pp_print_list ?pp_sep pp_item formatter list = match list with | [] -> () | hd :: tl -> pp_item formatter hd; match tl with | [] -> () | _ -> List.iter (fun item -> begin match pp_sep with | None -> () | Some pp_sep -> pp_sep formatter () end; pp_item formatter item) tl let pp_print_text formatter s = Stdcompat__string.iter (fun c -> match c with | ' ' -> pp_print_space formatter () | '\n' -> pp_force_newline formatter () | _ -> pp_print_char formatter c) s @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_12_0@ let rec pp_print_seq_cont pp_sep pp_item formatter (seq : _ Stdcompat__seq.t) = match seq () with | Stdcompat__seq.Nil -> () | Stdcompat__seq.Cons (hd, tl) -> begin match pp_sep with | None -> () | Some pp_sep -> pp_sep formatter () end; pp_item formatter hd; pp_print_seq_cont pp_sep pp_item formatter tl let pp_print_seq ?pp_sep pp_item formatter (seq : _ Stdcompat__seq.t) = match seq () with | Stdcompat__seq.Nil -> () | Stdcompat__seq.Cons (hd, tl) -> pp_item formatter hd; pp_print_seq_cont pp_sep pp_item formatter tl @END_BEFORE_4_12_0@ @BEGIN_BEFORE_3_12_0@ let ikfprintf _ = failwith "Not implemented." @END_BEFORE_3_12_0@ @BEGIN_BEFORE_3_10_0@ let ifprintf _ = failwith "Not implemented." @END_BEFORE_3_10_0@ @BEGIN_BEFORE_3_08_0@ let kfprintf _ = failwith "Not implemented." let ksprintf _ = failwith "Not implemented." @END_BEFORE_3_08_0@ @BEGIN_BEFORE_4_11_0@ let update_geometry _ = failwith "Not implemented." let pp_update_geometry _ = failwith "Not implemented." @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_13_0@ let pp_print_either ~left ~right fmt e = match e with | Stdcompat__either.Left l -> left fmt l | Stdcompat__either.Right r -> right fmt r let pp_print_bytes fmt bytes = pp_print_string fmt (Stdcompat__bytes.unsafe_to_string bytes) let print_bytes bytes = pp_print_bytes std_formatter bytes @END_BEFORE_4_13_0@ @BEGIN_BEFORE_5_1_0@ let pp_print_iter ?pp_sep iter pp_item fmt arg = let first = ref true in iter (fun v -> if !first then first := false else begin match pp_sep with Some pp_sep -> pp_sep fmt () | None -> () end; pp_item fmt v) arg let pp_print_array ?pp_sep pp_item fmt array = pp_print_iter ?pp_sep Array.iter pp_item fmt array @END_BEFORE_5_1_0@ @BEGIN_BEFORE_5_0_0@ let synchronized_formatter_of_out_channel _ = failwith "not implemented" let get_std_formatter () = std_formatter let get_err_formatter () = err_formatter let get_stdbuf () = stdbuf let get_str_formatter () = str_formatter let make_synchronized_formatter _ _ = failwith "not implemented" @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__format.mli.in000066400000000000000000000000361463722102200227310ustar00rootroot00000000000000include Stdcompat__format_s.S ocaml-stdcompat-20~git20240529/stdcompat__format_s.mli.in000066400000000000000000000660141463722102200232630ustar00rootroot00000000000000module type S = sig type formatter = Format.formatter (** Alias for {!Format.formatter} *) @BEGIN_FROM_4_08_0@ type geometry = Format.geometry = { max_indent: int ; margin: int } @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type geometry = { max_indent: int ; margin: int } @END_BEFORE_4_08_0@ (** @since 4.08.0: type geometry = { max_indent: int ; margin: int } *) @BEGIN_FROM_4_08_0@ @BEGIN_FROM_4_02_0@ type stag = Format.stag = .. @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type stag = Format.stag @END_BEFORE_4_02_0@ @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ type stag = .. @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type stag @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: type stag = .. *) type tag = string (** Alias for {!Format.tag} *) @BEGIN_FROM_4_06_0@ type formatter_out_functions = Format.formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } @END_BEFORE_4_06_0@ (** @since 4.06.0: type formatter_out_functions = { out_string: string -> int -> int -> unit ; out_flush: unit -> unit ; out_newline: unit -> unit ; out_spaces: int -> unit ; out_indent: int -> unit } *) @BEGIN_FROM_4_08_0@ type formatter_stag_functions = Format.formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } @END_BEFORE_4_08_0@ (** @since 4.08.0: type formatter_stag_functions = { mark_open_stag: stag -> string ; mark_close_stag: stag -> string ; print_open_stag: stag -> unit ; print_close_stag: stag -> unit } *) @BEGIN_FROM_4_06_0@ type symbolic_output_item = Format.symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int @END_BEFORE_4_06_0@ (** @since 4.06.0: type symbolic_output_item = | Output_flush | Output_newline | Output_string of string | Output_spaces of int | Output_indent of int *) @BEGIN_FROM_4_06_0@ type symbolic_output_buffer = Format.symbolic_output_buffer @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ type symbolic_output_buffer @END_BEFORE_4_06_0@ (** @since 4.06.0: type symbolic_output_buffer *) val pp_print_nothing : formatter -> unit -> unit (** @since 5.2.0: val pp_print_nothing : formatter -> unit -> unit *) val pp_infinity : int (** @since 5.2.0: val pp_infinity : int *) val pp_print_iter : ?pp_sep:(formatter -> unit -> unit) -> (('a -> unit) -> 'b -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'b -> unit (** @since 5.1.0: val pp_print_iter : ?pp_sep:(formatter -> unit -> unit) -> (('a -> unit) -> 'b -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'b -> unit *) val pp_print_array : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a array -> unit (** @since 5.1.0: val pp_print_array : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a array -> unit *) val synchronized_formatter_of_out_channel : out_channel -> formatter Stdcompat__domain.DLS.key (** @since 5.0.0: val synchronized_formatter_of_out_channel : out_channel -> formatter Stdcompat__domain.DLS.key *) val get_std_formatter : unit -> formatter (** @since 5.0.0: val get_std_formatter : unit -> formatter *) val get_err_formatter : unit -> formatter (** @since 5.0.0: val get_err_formatter : unit -> formatter *) val get_stdbuf : unit -> Buffer.t (** @since 5.0.0: val get_stdbuf : unit -> Buffer.t *) val get_str_formatter : unit -> formatter (** @since 5.0.0: val get_str_formatter : unit -> formatter *) val make_synchronized_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter Stdcompat__domain.DLS.key (** @since 5.0.0: val make_synchronized_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter Stdcompat__domain.DLS.key *) @BEGIN_FROM_4_13_0@ val pp_print_bytes : formatter -> bytes -> unit @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val pp_print_bytes : formatter -> Stdcompat__init.bytes -> unit @END_BEFORE_4_13_0@ (** @since 4.13.0: val pp_print_bytes : formatter -> bytes -> unit *) @BEGIN_FROM_4_13_0@ val print_bytes : bytes -> unit @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val print_bytes : Stdcompat__init.bytes -> unit @END_BEFORE_4_13_0@ (** @since 4.13.0: val print_bytes : bytes -> unit *) @BEGIN_FROM_4_13_0@ val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Stdcompat__either.t -> unit @END_BEFORE_4_13_0@ (** @since 4.13.0: val pp_print_either : left:(formatter -> 'a -> unit) -> right:(formatter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit *) @BEGIN_FROM_4_12_0@ val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Stdcompat__seq.t -> unit @END_BEFORE_4_12_0@ (** @since 4.12.0: val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a Seq.t -> unit *) val pp_update_geometry : formatter -> (geometry -> geometry) -> unit (** @since 4.11.0: val pp_update_geometry : formatter -> (geometry -> geometry) -> unit *) val update_geometry : (geometry -> geometry) -> unit (** @since 4.11.0: val update_geometry : (geometry -> geometry) -> unit *) val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit (** @since 4.08.0: val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit *) val check_geometry : geometry -> bool (** @since 4.08.0: val check_geometry : geometry -> bool *) val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit (** @since 4.08.0: val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit *) val set_geometry : max_indent:int -> margin:int -> unit (** @since 4.08.0: val set_geometry : max_indent:int -> margin:int -> unit *) val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit (** @since 4.08.0: val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit *) val safe_set_geometry : max_indent:int -> margin:int -> unit (** @since 4.08.0: val safe_set_geometry : max_indent:int -> margin:int -> unit *) val pp_get_geometry : formatter -> unit -> geometry (** @since 4.08.0: val pp_get_geometry : formatter -> unit -> geometry *) val get_geometry : unit -> geometry (** @since 4.08.0: val get_geometry : unit -> geometry *) val pp_open_stag : formatter -> stag -> unit (** @since 4.08.0: val pp_open_stag : formatter -> stag -> unit *) val open_stag : stag -> unit (** @since 4.08.0: val open_stag : stag -> unit *) val pp_close_stag : formatter -> unit -> unit (** @since 4.08.0: val pp_close_stag : formatter -> unit -> unit *) val close_stag : unit -> unit (** @since 4.08.0: val close_stag : unit -> unit *) val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit (** @since 4.08.0: val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit *) val set_formatter_stag_functions : formatter_stag_functions -> unit (** @since 4.08.0: val set_formatter_stag_functions : formatter_stag_functions -> unit *) val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions (** @since 4.08.0: val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions *) val get_formatter_stag_functions : unit -> formatter_stag_functions (** @since 4.08.0: val get_formatter_stag_functions : unit -> formatter_stag_functions *) val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit (** @since 4.08.0: val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit *) @BEGIN_FROM_4_08_0@ val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) Stdcompat__pervasives.result -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit *) val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a (** @since 4.08.0: val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a *) val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 4.08.0: val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b *) val formatter_of_out_functions : formatter_out_functions -> formatter (** @since 4.06.0: val formatter_of_out_functions : formatter_out_functions -> formatter *) val make_symbolic_output_buffer : unit -> symbolic_output_buffer (** @since 4.06.0: val make_symbolic_output_buffer : unit -> symbolic_output_buffer *) val clear_symbolic_output_buffer : symbolic_output_buffer -> unit (** @since 4.06.0: val clear_symbolic_output_buffer : symbolic_output_buffer -> unit *) val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list (** @since 4.06.0: val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list *) val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list (** @since 4.06.0: val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list *) val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit (** @since 4.06.0: val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit *) val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter (** @since 4.06.0: val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter *) val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 4.03.0: val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b *) val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit (** @since 4.02.0: val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit *) val pp_print_text : formatter -> string -> unit (** @since 4.02.0: val pp_print_text : formatter -> string -> unit *) val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit (** @since 4.01.0: val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit *) val set_formatter_out_functions : formatter_out_functions -> unit (** @since 4.01.0: val set_formatter_out_functions : formatter_out_functions -> unit *) val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions (** @since 4.01.0: val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions *) val get_formatter_out_functions : unit -> formatter_out_functions (** @since 4.01.0: val get_formatter_out_functions : unit -> formatter_out_functions *) val asprintf : ('a, formatter, unit, string) format4 -> 'a (** @since 4.01.0: val asprintf : ('a, formatter, unit, string) format4 -> 'a *) val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 3.12.0: val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b *) val ifprintf : formatter -> ('a, formatter, unit) format -> 'a (** @since 3.10.0: val ifprintf : formatter -> ('a, formatter, unit) format -> 'a *) val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 3.08.0: val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b *) val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b (** @since 3.08.0: val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b *) val pp_open_box : formatter -> int -> unit (** Alias for {!Format.pp_open_box} *) val open_box : int -> unit (** Alias for {!Format.open_box} *) val pp_close_box : formatter -> unit -> unit (** Alias for {!Format.pp_close_box} *) val close_box : unit -> unit (** Alias for {!Format.close_box} *) val pp_open_hbox : formatter -> unit -> unit (** Alias for {!Format.pp_open_hbox} *) val open_hbox : unit -> unit (** Alias for {!Format.open_hbox} *) val pp_open_vbox : formatter -> int -> unit (** Alias for {!Format.pp_open_vbox} *) val open_vbox : int -> unit (** Alias for {!Format.open_vbox} *) val pp_open_hvbox : formatter -> int -> unit (** Alias for {!Format.pp_open_hvbox} *) val open_hvbox : int -> unit (** Alias for {!Format.open_hvbox} *) val pp_open_hovbox : formatter -> int -> unit (** Alias for {!Format.pp_open_hovbox} *) val open_hovbox : int -> unit (** Alias for {!Format.open_hovbox} *) val pp_print_string : formatter -> string -> unit (** Alias for {!Format.pp_print_string} *) val print_string : string -> unit (** Alias for {!Format.print_string} *) val pp_print_as : formatter -> int -> string -> unit (** Alias for {!Format.pp_print_as} *) val print_as : int -> string -> unit (** Alias for {!Format.print_as} *) val pp_print_int : formatter -> int -> unit (** Alias for {!Format.pp_print_int} *) val print_int : int -> unit (** Alias for {!Format.print_int} *) val pp_print_float : formatter -> float -> unit (** Alias for {!Format.pp_print_float} *) val print_float : float -> unit (** Alias for {!Format.print_float} *) val pp_print_char : formatter -> char -> unit (** Alias for {!Format.pp_print_char} *) val print_char : char -> unit (** Alias for {!Format.print_char} *) val pp_print_bool : formatter -> bool -> unit (** Alias for {!Format.pp_print_bool} *) val print_bool : bool -> unit (** Alias for {!Format.print_bool} *) val pp_print_space : formatter -> unit -> unit (** Alias for {!Format.pp_print_space} *) val print_space : unit -> unit (** Alias for {!Format.print_space} *) val pp_print_cut : formatter -> unit -> unit (** Alias for {!Format.pp_print_cut} *) val print_cut : unit -> unit (** Alias for {!Format.print_cut} *) val pp_print_break : formatter -> int -> int -> unit (** Alias for {!Format.pp_print_break} *) val print_break : int -> int -> unit (** Alias for {!Format.print_break} *) val pp_force_newline : formatter -> unit -> unit (** Alias for {!Format.pp_force_newline} *) val force_newline : unit -> unit (** Alias for {!Format.force_newline} *) val pp_print_if_newline : formatter -> unit -> unit (** Alias for {!Format.pp_print_if_newline} *) val print_if_newline : unit -> unit (** Alias for {!Format.print_if_newline} *) val pp_print_flush : formatter -> unit -> unit (** Alias for {!Format.pp_print_flush} *) val print_flush : unit -> unit (** Alias for {!Format.print_flush} *) val pp_print_newline : formatter -> unit -> unit (** Alias for {!Format.pp_print_newline} *) val print_newline : unit -> unit (** Alias for {!Format.print_newline} *) val pp_set_margin : formatter -> int -> unit (** Alias for {!Format.pp_set_margin} *) val set_margin : int -> unit (** Alias for {!Format.set_margin} *) val pp_get_margin : formatter -> unit -> int (** Alias for {!Format.pp_get_margin} *) val get_margin : unit -> int (** Alias for {!Format.get_margin} *) val pp_set_max_indent : formatter -> int -> unit (** Alias for {!Format.pp_set_max_indent} *) val set_max_indent : int -> unit (** Alias for {!Format.set_max_indent} *) val pp_get_max_indent : formatter -> unit -> int (** Alias for {!Format.pp_get_max_indent} *) val get_max_indent : unit -> int (** Alias for {!Format.get_max_indent} *) val pp_set_max_boxes : formatter -> int -> unit (** Alias for {!Format.pp_set_max_boxes} *) val set_max_boxes : int -> unit (** Alias for {!Format.set_max_boxes} *) val pp_get_max_boxes : formatter -> unit -> int (** Alias for {!Format.pp_get_max_boxes} *) val get_max_boxes : unit -> int (** Alias for {!Format.get_max_boxes} *) val pp_over_max_boxes : formatter -> unit -> bool (** Alias for {!Format.pp_over_max_boxes} *) val over_max_boxes : unit -> bool (** Alias for {!Format.over_max_boxes} *) @BEGIN_FROM_4_06_0@ val pp_open_tbox : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_open_tbox : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_open_tbox : formatter -> unit -> unit @since 4.03.0: val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_open_tbox : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val open_tbox : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val open_tbox : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val open_tbox : unit -> unit @since 4.03.0: val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val open_tbox : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_close_tbox : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_close_tbox : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_close_tbox : formatter -> unit -> unit @since 4.03.0: val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_close_tbox : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val close_tbox : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val close_tbox : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val close_tbox : unit -> unit @since 4.03.0: val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val close_tbox : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_set_tab : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_set_tab : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_set_tab : formatter -> unit -> unit @since 4.03.0: val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_set_tab : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val set_tab : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val set_tab : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val set_tab : unit -> unit @since 4.03.0: val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val set_tab : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_print_tab : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_print_tab : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_print_tab : formatter -> unit -> unit @since 4.03.0: val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_print_tab : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val print_tab : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val print_tab : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val print_tab : unit -> unit @since 4.03.0: val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val print_tab : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_print_tbreak : formatter -> int -> int -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_print_tbreak : formatter -> int -> int -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_print_tbreak : formatter -> int -> int -> unit @since 4.03.0: val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_print_tbreak : formatter -> int -> int -> unit *) @BEGIN_FROM_4_06_0@ val print_tbreak : int -> int -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val print_tbreak : int -> int -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val print_tbreak : int -> int -> unit @since 4.03.0: val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val print_tbreak : int -> int -> unit *) val pp_set_ellipsis_text : formatter -> string -> unit (** Alias for {!Format.pp_set_ellipsis_text} *) val set_ellipsis_text : string -> unit (** Alias for {!Format.set_ellipsis_text} *) val pp_get_ellipsis_text : formatter -> unit -> string (** Alias for {!Format.pp_get_ellipsis_text} *) val get_ellipsis_text : unit -> string (** Alias for {!Format.get_ellipsis_text} *) val pp_set_tags : formatter -> bool -> unit (** Alias for {!Format.pp_set_tags} *) val set_tags : bool -> unit (** Alias for {!Format.set_tags} *) val pp_set_print_tags : formatter -> bool -> unit (** Alias for {!Format.pp_set_print_tags} *) val set_print_tags : bool -> unit (** Alias for {!Format.set_print_tags} *) val pp_set_mark_tags : formatter -> bool -> unit (** Alias for {!Format.pp_set_mark_tags} *) val set_mark_tags : bool -> unit (** Alias for {!Format.set_mark_tags} *) val pp_get_print_tags : formatter -> unit -> bool (** Alias for {!Format.pp_get_print_tags} *) val get_print_tags : unit -> bool (** Alias for {!Format.get_print_tags} *) val pp_get_mark_tags : formatter -> unit -> bool (** Alias for {!Format.pp_get_mark_tags} *) val get_mark_tags : unit -> bool (** Alias for {!Format.get_mark_tags} *) val pp_set_formatter_out_channel : formatter -> out_channel -> unit (** Alias for {!Format.pp_set_formatter_out_channel} *) val set_formatter_out_channel : out_channel -> unit (** Alias for {!Format.set_formatter_out_channel} *) val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit (** Alias for {!Format.pp_set_formatter_output_functions} *) val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit (** Alias for {!Format.set_formatter_output_functions} *) val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) (** Alias for {!Format.pp_get_formatter_output_functions} *) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) (** Alias for {!Format.get_formatter_output_functions} *) val formatter_of_out_channel : out_channel -> formatter (** Alias for {!Format.formatter_of_out_channel} *) val std_formatter : formatter (** Alias for {!Format.std_formatter} *) val err_formatter : formatter (** Alias for {!Format.err_formatter} *) val formatter_of_buffer : Buffer.t -> formatter (** Alias for {!Format.formatter_of_buffer} *) val stdbuf : Buffer.t (** Alias for {!Format.stdbuf} *) val str_formatter : formatter (** Alias for {!Format.str_formatter} *) val flush_str_formatter : unit -> string (** Alias for {!Format.flush_str_formatter} *) val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter (** Alias for {!Format.make_formatter} *) val fprintf : formatter -> ('a, formatter, unit) format -> 'a (** Alias for {!Format.fprintf} *) val printf : ('a, formatter, unit) format -> 'a (** Alias for {!Format.printf} *) val eprintf : ('a, formatter, unit) format -> 'a (** Alias for {!Format.eprintf} *) val sprintf : ('a, unit, string) format -> 'a (** Alias for {!Format.sprintf} *) end ocaml-stdcompat-20~git20240529/stdcompat__fun.ml.in000066400000000000000000000016201463722102200220600ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Fun @END_FROM_4_08_0@ @BEGIN_BEFORE_5_2_0@ let compose f g x = f (g x) @END_BEFORE_5_2_0@ @BEGIN_BEFORE_4_08_0@ external id : 'a -> 'a = "%identity" (** @since 4.08.0: external id : 'a -> 'a = "%identity" *) let const c _ = c let flip f x y = f y x let negate f x = not (f x) exception Finally_raised of exn let protect ~finally f = let value = try Stdcompat__pervasives.Ok (f ()) with exn -> let bt = Stdcompat__printexc.get_raw_backtrace () in Stdcompat__pervasives.Error (exn, bt) in begin try finally () with exn -> let bt = Stdcompat__printexc.get_raw_backtrace () in Stdcompat__printexc.raise_with_backtrace (Finally_raised exn) bt end; match value with | Stdcompat__pervasives.Ok result -> result | Stdcompat__pervasives.Error (exn, bt) -> Stdcompat__printexc.raise_with_backtrace exn bt @END_BEFORE_4_08_0@ ocaml-stdcompat-20~git20240529/stdcompat__fun.mli.in000066400000000000000000000000331463722102200222260ustar00rootroot00000000000000include Stdcompat__fun_s.S ocaml-stdcompat-20~git20240529/stdcompat__fun_s.mli.in000066400000000000000000000013621463722102200225560ustar00rootroot00000000000000module type S = sig exception Finally_raised of exn (** Alias for {!Fun.Finally_raised} *) val compose : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c (** @since 5.2.0: val compose : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c *) external id : 'a -> 'a = "%identity" (** @since 4.08.0: external id : 'a -> 'a = "%identity" *) val const : 'a -> 'b -> 'a (** @since 4.08.0: val const : 'a -> 'b -> 'a *) val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c (** @since 4.08.0: val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c *) val negate : ('a -> bool) -> 'a -> bool (** @since 4.08.0: val negate : ('a -> bool) -> 'a -> bool *) val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a (** @since 4.08.0: val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a *) end ocaml-stdcompat-20~git20240529/stdcompat__hashtbl.ml.in000066400000000000000000000245771463722102200227350ustar00rootroot00000000000000type statistics = Stdcompat__hashtbl_ext.statistics = { num_bindings : int; num_buckets : int; max_bucket_length : int; bucket_histogram : int array; } type ('a, 'b) t = ('a, 'b) Hashtbl.t let clear = Hashtbl.clear let copy = Hashtbl.copy let add = Hashtbl.add let find = Hashtbl.find let find_all = Hashtbl.find_all let mem = Hashtbl.mem let remove = Hashtbl.remove let replace = Hashtbl.replace let iter = Hashtbl.iter let fold = Hashtbl.fold module type HashedType = Hashtbl.HashedType let hash = Hashtbl.hash @BEGIN_FROM_4_07_0@ let to_seq = Hashtbl.to_seq let to_seq_values = Hashtbl.to_seq_values let to_seq_keys = Hashtbl.to_seq_keys let replace_seq = Hashtbl.replace_seq let add_seq = Hashtbl.add_seq let of_seq = Hashtbl.of_seq @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ @BEGIN_WITH_MAGIC@ let to_seq = Stdcompat__hashtbl_ext.to_seq let to_seq_keys = Stdcompat__hashtbl_ext.to_seq_keys let to_seq_values = Stdcompat__hashtbl_ext.to_seq_values @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_seq tbl = Stdcompat__hashtbl_ext.to_seq Hashtbl.fold tbl let to_seq_keys tbl = Stdcompat__hashtbl_ext.to_seq_keys Hashtbl.fold tbl let to_seq_values tbl = Stdcompat__hashtbl_ext.to_seq_values Hashtbl.fold tbl @END_WITHOUT_MAGIC@ let add_seq tbl g = Stdcompat__hashtbl_ext.add_seq Hashtbl.add tbl g let replace_seq tbl g = Stdcompat__hashtbl_ext.add_seq Hashtbl.replace tbl g let of_seq g = Stdcompat__hashtbl_ext.of_seq ~create:Hashtbl.create ~replace:Hashtbl.replace g @END_BEFORE_4_07_0@ @BEGIN_FROM_4_05_0@ let find_opt = Hashtbl.find_opt @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ @BEGIN_FROM_4_03_0@ let is_randomized = Hashtbl.is_randomized let filter_map_inplace = Hashtbl.filter_map_inplace @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ let is_randomized () = false @BEGIN_WITH_MAGIC@ let filter_map_inplace filter table = Stdcompat__hashtbl_ext.filter_map_inplace filter table @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let filter_map_inplace filter table = let dict = { Stdcompat__hashtbl_ext.clear = clear; Stdcompat__hashtbl_ext.fold = fold; Stdcompat__hashtbl_ext.add = add; Stdcompat__hashtbl_ext.remove = remove; Stdcompat__hashtbl_ext.replace = replace; } in Stdcompat__hashtbl_ext.filter_map_inplace dict filter table @END_WITHOUT_MAGIC@ @END_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ let length = Hashtbl.length @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ @BEGIN_WITH_MAGIC@ let length (table : ('a, 'b) t) = let table : ('a, 'b) Stdcompat__hashtbl_ext.internal = Obj.magic table in table.Stdcompat__hashtbl_ext.size @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let length table = fold (fun _ _ counter -> succ counter) table 0 @END_WITHOUT_MAGIC@ @END_BEFORE_3_08_0@ @BEGIN_FROM_4_00_0@ let create = Hashtbl.create let reset = Hashtbl.clear let randomize = Hashtbl.randomize let hash_param = Hashtbl.hash_param let seeded_hash = Hashtbl.seeded_hash let seeded_hash_param = Hashtbl.seeded_hash_param let stats = Hashtbl.stats @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ let create ?random n = Hashtbl.create n let reset = clear let randomize () = () @BEGIN_FROM_3_08_0@ external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external hash_param : int -> int -> 'a -> int = "hash_univ_param" "noalloc" @END_BEFORE_3_08_0@ let seeded_hash seed x = Hashtbl.hash (seed, x) let seeded_hash_param meaningful total seed x = Hashtbl.hash_param meaningful total (seed, x) @BEGIN_WITH_MAGIC@ let stats (h : ('a, 'b) t) = Stdcompat__hashtbl_ext.stats h @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let stats h = Stdcompat__hashtbl_ext.stats ~length h @END_WITHOUT_MAGIC@ @END_BEFORE_4_00_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @BEGIN_FROM_4_07_0@ module Make = Hashtbl.Make @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module Make (H : HashedType) = struct include Hashtbl.Make (H) @BEGIN_WITH_MAGIC@ let to_seq = Stdcompat__hashtbl_ext.to_seq let to_seq_keys = Stdcompat__hashtbl_ext.to_seq_keys let to_seq_values = Stdcompat__hashtbl_ext.to_seq_values @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_seq tbl = Stdcompat__hashtbl_ext.to_seq fold tbl let to_seq_keys tbl = Stdcompat__hashtbl_ext.to_seq_keys fold tbl let to_seq_values tbl = Stdcompat__hashtbl_ext.to_seq_values fold tbl @END_WITHOUT_MAGIC@ let add_seq tbl g = Stdcompat__hashtbl_ext.add_seq add tbl g let replace_seq tbl g = Stdcompat__hashtbl_ext.add_seq replace tbl g let of_seq g = Stdcompat__hashtbl_ext.of_seq ~create ~replace g @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_MAGIC@ let filter_map_inplace filter table = Stdcompat__hashtbl_ext.filter_map_inplace filter table @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let filter_map_inplace filter table = let dict = { Stdcompat__hashtbl_ext.clear = clear; Stdcompat__hashtbl_ext.fold = fold; Stdcompat__hashtbl_ext.add = add; Stdcompat__hashtbl_ext.remove = remove; Stdcompat__hashtbl_ext.replace = replace; } in Stdcompat__hashtbl_ext.filter_map_inplace dict filter table @END_WITHOUT_MAGIC@ @END_BEFORE_4_03_0@ @BEGIN_BEFORE_3_08_0@ @BEGIN_WITH_MAGIC@ let length (table : 'a t) = let table : (key, 'a) Stdcompat__hashtbl_ext.internal = Obj.magic table in table.Stdcompat__hashtbl_ext.size @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let length table = fold (fun _ _ counter -> succ counter) table 0 @END_WITHOUT_MAGIC@ @END_BEFORE_3_08_0@ @BEGIN_BEFORE_4_00_0@ let create capacity = create capacity let reset = clear @BEGIN_WITH_MAGIC@ let stats (h : 'a t) = Stdcompat__hashtbl_ext.stats h @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let stats h = Stdcompat__hashtbl_ext.stats ~length h @END_WITHOUT_MAGIC@ @END_BEFORE_4_00_0@ end @END_BEFORE_4_07_0@ module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @BEGIN_FROM_5_0_0@ module MakeSeeded = Hashtbl.MakeSeeded @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module MakeSeeded (H : SeededHashedType) = struct include Stdcompat__hashtbl_ext.MakeSeeded (H) @BEGIN_WITH_MAGIC@ let to_seq = Stdcompat__hashtbl_ext.to_seq let to_seq_keys = Stdcompat__hashtbl_ext.to_seq_keys let to_seq_values = Stdcompat__hashtbl_ext.to_seq_values @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_seq tbl = Stdcompat__hashtbl_ext.to_seq fold tbl let to_seq_keys tbl = Stdcompat__hashtbl_ext.to_seq_keys fold tbl let to_seq_values tbl = Stdcompat__hashtbl_ext.to_seq_values fold tbl @END_WITHOUT_MAGIC@ let add_seq tbl g = Stdcompat__hashtbl_ext.add_seq add tbl g let replace_seq tbl g = Stdcompat__hashtbl_ext.add_seq replace tbl g let of_seq g = Stdcompat__hashtbl_ext.of_seq ~create ~replace g @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_MAGIC@ let filter_map_inplace filter table = Stdcompat__hashtbl_ext.filter_map_inplace filter table @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let filter_map_inplace filter table = let dict = { Stdcompat__hashtbl_ext.clear = clear; Stdcompat__hashtbl_ext.fold = fold; Stdcompat__hashtbl_ext.add = add; Stdcompat__hashtbl_ext.remove = remove; Stdcompat__hashtbl_ext.replace = replace; } in Stdcompat__hashtbl_ext.filter_map_inplace dict filter table @END_WITHOUT_MAGIC@ @END_BEFORE_4_03_0@ @BEGIN_BEFORE_3_08_0@ @BEGIN_WITH_MAGIC@ let length (table : 'a t) = let table : (key, 'a) Stdcompat__hashtbl_ext.internal = Obj.magic table in table.Stdcompat__hashtbl_ext.size @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let length table = fold (fun _ _ counter -> succ counter) table 0 @END_WITHOUT_MAGIC@ @END_BEFORE_3_08_0@ @BEGIN_BEFORE_4_00_0@ let create ?random capacity = create capacity let reset = clear let stats tbl = { num_bindings = length tbl; num_buckets = 0; max_bucket_length = 0; bucket_histogram = [| |]; } @END_BEFORE_4_00_0@ end @END_BEFORE_5_0_0@ @BEGIN_FROM_4_12_0@ let rebuild = Hashtbl.rebuild @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ let rebuild ?random tbl = let result = create ?random (stats tbl).num_buckets in iter (add result) tbl; result @END_BEFORE_4_12_0@ ocaml-stdcompat-20~git20240529/stdcompat__hashtbl.mli.in000066400000000000000000000000371463722102200230670ustar00rootroot00000000000000include Stdcompat__hashtbl_s.S ocaml-stdcompat-20~git20240529/stdcompat__hashtbl_ext.ml.in000066400000000000000000000124001463722102200235730ustar00rootroot00000000000000module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end @BEGIN_FROM_4_00_0@ @BEGIN_FROM_5_0_0@ module ToOCamlSeededHashedType (M : SeededHashedType) = M module MakeSeeded = Hashtbl.MakeSeeded @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module ToOCamlSeededHashedType (M : SeededHashedType) = struct type t = M.t let equal = M.equal let hash = M.seeded_hash end module MakeSeeded (M : SeededHashedType) = Hashtbl.MakeSeeded (ToOCamlSeededHashedType (M)) @END_BEFORE_5_0_0@ @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ module ToOCamlSeededHashedType (M : SeededHashedType) = struct type t = M.t let equal = M.equal let hash x = M.seeded_hash 0 x end module MakeSeeded (M : SeededHashedType) = Hashtbl.Make (ToOCamlSeededHashedType (M)) @END_BEFORE_4_00_0@ type statistics @BEGIN_FROM_4_00_0@ = Hashtbl.statistics @END_FROM_4_00_0@ = { num_bindings : int; num_buckets : int; max_bucket_length : int; bucket_histogram : int array; } @BEGIN_WITH_MAGIC@ type ('a, 'b) bucketlist = | Empty | Cons of 'a * 'b * ('a, 'b) bucketlist @BEGIN_FROM_4_04_0@ type ('a, 'b) internal = { mutable size: int; mutable data: ('a, 'b) bucketlist array; mutable seed: int; mutable initial_size: int; } @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_00_0@ type ('a, 'b) internal = { mutable size: int; mutable data: ('a, 'b) bucketlist array; mutable seed: int; initial_size: int; } @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ type ('a, 'b) internal = { mutable size: int; mutable data: ('a, 'b) bucketlist array; } @END_BEFORE_4_00_0@ @END_BEFORE_4_04_0@ let filter_map_inplace f h = let h : ('a, 'b) internal = Obj.magic h in let rec do_bucket = function | Empty -> Empty | Cons (k, d, rest) -> match f k d with | None -> h.size <- h.size - 1; do_bucket rest | Some new_d -> Cons (k, new_d, do_bucket rest) in let d = h.data in for i = 0 to Array.length d - 1 do d.(i) <- do_bucket d.(i) done let to_seq h = let h : ('a, 'b) internal = Obj.magic h in let h_data = h.data in let rec aux i buck () = match buck with | Empty -> if i = Array.length h_data then Stdcompat__seq.Nil else aux (i+1) h_data.(i) () | Cons (key, data, next) -> Stdcompat__seq.Cons ((key, data), aux i next) in aux 0 Empty let to_seq_keys h = Stdcompat__seq.map fst (to_seq h) let to_seq_values h = Stdcompat__seq.map snd (to_seq h) let rec bucket_length accu = function | Empty -> accu | Cons (_, _, rest) -> bucket_length (accu + 1) rest let stats_internal h = let mbl = Array.fold_left (fun m b -> max m (bucket_length 0 b)) 0 h.data in let histo = Array.make (mbl + 1) 0 in Array.iter (fun b -> let l = bucket_length 0 b in histo.(l) <- histo.(l) + 1) h.data; { num_bindings = h.size; num_buckets = Array.length h.data; max_bucket_length = mbl; bucket_histogram = histo } let stats h = let h : ('a, 'b) internal = Obj.magic h in stats_internal h @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ type ('table, 'key, 'value) dict = { clear : 'table -> unit; fold : 'a . ('key -> 'value -> 'a -> 'a) -> 'table -> 'a -> 'a; add : 'table -> 'key -> 'value -> unit; remove : 'table -> 'key -> unit; replace : 'table -> 'key -> 'value -> unit; } let filter_map_inplace dict filter hashtbl = let f key value (last_key, to_replace, to_add, to_remove, rebuild, changed) = match filter key value with | None -> if rebuild || last_key = Some key then (Some key, to_replace, to_add, to_remove, true, true) else (None, to_replace, to_add, key :: to_remove, false, true) | Some value0 -> if value == value0 then (Some key, to_replace, (key, value0) :: to_add, to_remove, rebuild, changed) else if rebuild || last_key = Some key then (Some key, to_replace, (key, value0) :: to_add, to_remove, true, true) else (Some key, (key, value0) :: to_replace, to_add, to_remove, false, true) in let _last_key, to_replace, to_add, to_remove, rebuild, changed = dict.fold f hashtbl (None, [], [], [], false, false) in if rebuild then begin dict.clear hashtbl; List.iter (fun (key, value) -> dict.add hashtbl key value) to_add; List.iter (fun (key, value) -> dict.add hashtbl key value) to_replace end else if changed then begin List.iter (fun key -> dict.remove hashtbl key) to_remove; List.iter (fun (key, value) -> dict.replace hashtbl key value) to_replace end let to_list fold tbl = fold (fun key value accu -> (key, value) :: accu) tbl [] let to_seq fold tbl = Stdcompat__list.to_seq (to_list fold tbl) let to_seq_keys fold h = Stdcompat__seq.map fst (to_seq fold h) let to_seq_values fold h = Stdcompat__seq.map snd (to_seq fold h) let stats ~length tbl = { num_bindings = length tbl; num_buckets = 0; max_bucket_length = 0; bucket_histogram = [| |]; } @END_WITHOUT_MAGIC@ let add_seq add tbl g = Stdcompat__seq.iter (fun (k, v) -> add tbl k v) g let of_seq ~create ~replace g = let tbl = create 17 in add_seq replace tbl g; tbl ocaml-stdcompat-20~git20240529/stdcompat__hashtbl_ext.mli.in000066400000000000000000000063201463722102200237500ustar00rootroot00000000000000module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end @BEGIN_FROM_4_00_0@ module ToOCamlSeededHashedType (M : SeededHashedType) : Hashtbl.SeededHashedType with type t = M.t @BEGIN_FROM_5_0_0@ module MakeSeeded = Hashtbl.MakeSeeded @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module MakeSeeded (M : SeededHashedType) : Hashtbl.SeededS with type 'a t = 'a Hashtbl.MakeSeeded (ToOCamlSeededHashedType (M)).t and type key = M.t @END_BEFORE_5_0_0@ @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ module ToOCamlSeededHashedType (M : SeededHashedType) : Hashtbl.HashedType with type t = M.t module MakeSeeded (M : SeededHashedType) : Hashtbl.S with type 'a t = 'a Hashtbl.Make (ToOCamlSeededHashedType (M)).t and type key = M.t @END_BEFORE_4_00_0@ type statistics @BEGIN_FROM_4_00_0@ = Hashtbl.statistics @END_FROM_4_00_0@ = { num_bindings : int; num_buckets : int; max_bucket_length : int; bucket_histogram : int array; } @BEGIN_WITH_MAGIC@ type ('a, 'b) bucketlist = | Empty | Cons of 'a * 'b * ('a, 'b) bucketlist @BEGIN_FROM_4_04_0@ type ('a, 'b) internal = { mutable size: int; mutable data: ('a, 'b) bucketlist array; mutable seed: int; mutable initial_size: int; } @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_FROM_4_00_0@ type ('a, 'b) internal = { mutable size: int; mutable data: ('a, 'b) bucketlist array; mutable seed: int; initial_size: int; } @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ type ('a, 'b) internal = { mutable size: int; mutable data: ('a, 'b) bucketlist array; } @END_BEFORE_4_00_0@ @END_BEFORE_4_04_0@ val filter_map_inplace : ('a -> 'b -> 'b option) -> 'c -> unit val to_seq : 'a -> ('b * 'c) Stdcompat__seq.t val to_seq_keys : 'a -> 'b Stdcompat__seq.t val to_seq_values : 'a -> 'b Stdcompat__seq.t val stats : 'a -> statistics @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ type ('table, 'key, 'value) dict = { clear : 'table -> unit; fold : 'a . ('key -> 'value -> 'a -> 'a) -> 'table -> 'a -> 'a; add : 'table -> 'key -> 'value -> unit; remove : 'table -> 'key -> unit; replace : 'table -> 'key -> 'value -> unit; } val filter_map_inplace : ('table, 'key, 'value) dict -> ('key -> 'value -> 'value option) -> 'table -> unit val to_seq : (('key -> 'value -> ('key * 'value) list -> ('key * 'value) list) -> 'table -> ('key * 'value) list -> ('key * 'value) list) -> 'table -> ('key * 'value) Stdcompat__seq.t val to_seq_keys : (('key -> 'value -> ('key * 'value) list -> ('key * 'value) list) -> 'table -> ('key * 'value) list -> ('key * 'value) list) -> 'table -> 'key Stdcompat__seq.t val to_seq_values : (('key -> 'value -> ('key * 'value) list -> ('key * 'value) list) -> 'table -> ('key * 'value) list -> ('key * 'value) list) -> 'table -> 'value Stdcompat__seq.t val stats : length:('table -> int) -> 'table -> statistics @END_WITHOUT_MAGIC@ val add_seq : ('table -> 'key -> 'value -> unit) -> 'table -> ('key * 'value) Stdcompat__seq.t -> unit val of_seq : create:(int -> 'table) -> replace:('table -> 'key -> 'value -> unit) -> ('key * 'value) Stdcompat__seq.t -> 'table ocaml-stdcompat-20~git20240529/stdcompat__hashtbl_s.mli.in000066400000000000000000000437231463722102200234220ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_12_0@ type (!'a, !'b) t = ('a, 'b) Hashtbl.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type ('a, 'b) t = ('a, 'b) Hashtbl.t @END_BEFORE_4_12_0@ (** Alias for {!Hashtbl.t} *) @BEGIN_FROM_4_00_0@ type statistics = Hashtbl.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ type statistics = Stdcompat__hashtbl_ext.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } @END_BEFORE_4_00_0@ (** @since 4.00.0: type statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } *) module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end (** Alias for {!Hashtbl.HashedType} *) @BEGIN_FROM_5_1_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_07_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module type S = sig type key type 'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @END_BEFORE_4_07_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end @since 4.07.0: module type S = sig type key type !'a t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end *) @BEGIN_FROM_4_07_0@ module Make = Hashtbl.Make @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @END_BEFORE_4_07_0@ (** @since 4.07.0: module Make = Hashtbl.Make *) @BEGIN_FROM_5_0_0@ module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end @END_BEFORE_5_0_0@ (** @since 5.0.0: module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end *) @BEGIN_FROM_5_1_0@ module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_07_0@ module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module type SeededS = sig type key type 'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @END_BEFORE_4_07_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end @since 4.07.0: module type SeededS = sig type key type !'a t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Seq.t val to_seq_keys : 'a t -> key Seq.t val to_seq_values : 'a t -> 'a Seq.t val add_seq : 'a t -> (key * 'a) Seq.t -> unit val replace_seq : 'a t -> (key * 'a) Seq.t -> unit val of_seq : (key * 'a) Seq.t -> 'a t end *) @BEGIN_FROM_5_0_0@ module MakeSeeded = Hashtbl.MakeSeeded @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Stdcompat__hashtbl_ext.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key -> 'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key -> 'a -> unit val mem : 'a t -> key -> bool val iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @END_BEFORE_5_0_0@ (** @since 5.0.0: module MakeSeeded = Hashtbl.MakeSeeded *) val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t (** @since 4.12.0: val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t *) @BEGIN_FROM_4_07_0@ val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : ('a, 'b) t -> ('a * 'b) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : ('a, 'b) t -> ('a * 'b) Seq.t *) @BEGIN_FROM_4_07_0@ val to_seq_keys : ('a, 'b) t -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq_keys : ('a, 'b) t -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq_keys : ('a, 'b) t -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val to_seq_values : ('a, 'b) t -> 'b Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq_values : ('a, 'b) t -> 'b Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq_values : ('a, 'b) t -> 'b Seq.t *) @BEGIN_FROM_4_07_0@ val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val add_seq : ('a, 'b) t -> ('a * 'b) Stdcompat__seq.t -> unit @END_BEFORE_4_07_0@ (** @since 4.07.0: val add_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit *) @BEGIN_FROM_4_07_0@ val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val replace_seq : ('a, 'b) t -> ('a * 'b) Stdcompat__seq.t -> unit @END_BEFORE_4_07_0@ (** @since 4.07.0: val replace_seq : ('a, 'b) t -> ('a * 'b) Seq.t -> unit *) @BEGIN_FROM_4_07_0@ val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : ('a * 'b) Stdcompat__seq.t -> ('a, 'b) t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t *) val find_opt : ('a, 'b) t -> 'a -> 'b option (** @since 4.05.0: val find_opt : ('a, 'b) t -> 'a -> 'b option *) val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit (** @since 4.03.0: val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit *) val is_randomized : unit -> bool (** @since 4.03.0: val is_randomized : unit -> bool *) val create : ?random:bool -> int -> ('a, 'b) t (** @since 4.00.0: val create : ?random:bool -> int -> ('a, 'b) t *) val reset : ('a, 'b) t -> unit (** @since 4.00.0: val reset : ('a, 'b) t -> unit *) val randomize : unit -> unit (** @since 4.00.0: val randomize : unit -> unit *) val stats : ('a, 'b) t -> statistics (** @since 4.00.0: val stats : ('a, 'b) t -> statistics *) val seeded_hash : int -> 'a -> int (** @since 4.00.0: val seeded_hash : int -> 'a -> int *) val seeded_hash_param : int -> int -> int -> 'a -> int (** @since 4.00.0: val seeded_hash_param : int -> int -> int -> 'a -> int *) val length : ('a, 'b) t -> int (** @since 3.08.0: val length : ('a, 'b) t -> int *) val clear : ('a, 'b) t -> unit (** Alias for {!Hashtbl.clear} *) val copy : ('a, 'b) t -> ('a, 'b) t (** Alias for {!Hashtbl.copy} *) val add : ('a, 'b) t -> 'a -> 'b -> unit (** Alias for {!Hashtbl.add} *) val find : ('a, 'b) t -> 'a -> 'b (** Alias for {!Hashtbl.find} *) val find_all : ('a, 'b) t -> 'a -> 'b list (** Alias for {!Hashtbl.find_all} *) val mem : ('a, 'b) t -> 'a -> bool (** Alias for {!Hashtbl.mem} *) val remove : ('a, 'b) t -> 'a -> unit (** Alias for {!Hashtbl.remove} *) val replace : ('a, 'b) t -> 'a -> 'b -> unit (** Alias for {!Hashtbl.replace} *) val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit (** Alias for {!Hashtbl.iter} *) @BEGIN_FROM_5_1_0@ val fold : ('a -> 'b -> 'acc -> 'acc) -> ('a, 'b) t -> 'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold : ('a -> 'b -> 'acc -> 'acc) -> ('a, 'b) t -> 'acc -> 'acc @since 3.07.0: val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c *) val hash : 'a -> int (** Alias for {!Hashtbl.hash} *) @BEGIN_FROM_4_00_0@ val hash_param : int -> int -> 'a -> int @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ @BEGIN_FROM_3_08_0@ external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external hash_param : int -> int -> 'a -> int = "hash_univ_param" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_00_0@ (** @since 4.00.0: val hash_param : int -> int -> 'a -> int @since 3.08.0: external hash_param : int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc" @since 3.07.0: external hash_param : int -> int -> 'a -> int = "hash_univ_param" "noalloc" *) end ocaml-stdcompat-20~git20240529/stdcompat__in_channel.ml.in000066400000000000000000000101401463722102200233630ustar00rootroot00000000000000@BEGIN_FROM_4_14_0@ include In_channel @END_FROM_4_14_0@ @BEGIN_BEFORE_5_2_0@ (* let max_buffer_size = 0x1000000 let input_and_copy_to_bigarray channel buffer tgt pos len = let read = input channel buffer 0 len in for i = 0 to read - 1 do Bigarray.Array1.unsafe_set tgt (pos + i) (int_of_char (Bytes.unsafe_get buffer i)) done; read let rec input_and_copy_to_bigarray_loop channel buffer tgt pos len already_read = let buffer_length = Bytes.length buffer in if buffer_length < len then begin let read = input_and_copy_to_bigarray channel buffer tgt pos buffer_length in let already_read = already_read + read in if read = buffer_length then input_and_copy_to_bigarray_loop channel buffer tgt (pos + read) (len - read) already_read else already_read end else begin let read = input_and_copy_to_bigarray channel buffer tgt pos len in already_read + read end let input_bigarray channel tgt pos len = if len < 0 || pos + len >= Bigarray.Array1.dim tgt then invalid_arg "input_bigarray"; let buffer_size = min max_buffer_size len in let buffer = Bytes.create buffer_size in input_and_copy_to_bigarray_loop channel buffer tgt pos len 0 let really_input_bigarray channel tgt pos len = if len < 0 || pos + len >= Bigarray.Array1.dim tgt then invalid_arg "input_bigarray"; let buffer_size = min max_buffer_size len in let buffer = Bytes.create buffer_size in let rec loop len = let read = input_and_copy_to_bigarray_loop channel buffer tgt pos len 0 in if read = 0 then None else if read < len then Some () else loop (len - read) in loop len *) let input_bigarray _channel _tgt _pos _len = failwith "input_bigarray" let really_input_bigarray _channel _tgt _pos _len = failwith "really_input_bigarray" let is_binary_mode _channel = failwith "is_binary_mode" @END_BEFORE_5_2_0@ @BEGIN_BEFORE_4_14_0@ type t = in_channel type open_flag = Pervasives.open_flag = Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock let stdin = stdin let open_bin = open_in_bin let open_text = open_in let open_gen = open_in_gen let read_and_close channel f = Stdcompat__fun.protect ~finally:(fun () -> close_in_noerr channel) (fun () -> f channel) let with_open_bin filename f = read_and_close (open_bin filename) f let with_open_text filename f = read_and_close (open_text filename) f let with_open_gen flags perm filename f = read_and_close (open_gen flags perm filename) f let seek = LargeFile.seek_in let pos = LargeFile.pos_in let length = LargeFile.in_channel_length let close = close_in let close_noerr = close_in_noerr let input_char ic = try Some (input_char ic) with End_of_file -> None let input_byte ic = try Some (input_byte ic) with End_of_file -> None let input_line ic = try Some (input_line ic) with End_of_file -> None let input = input let really_input ic buf pos len = try really_input ic buf pos len; Some () with End_of_file -> None let really_input_string ic len = try Some (Stdcompat__pervasives.really_input_string ic len) with End_of_file -> None let set_binary_mode = set_binary_mode_in let rec add_channel_to_the_end ~chunk_size buffer channel = if try Stdcompat__buffer.add_channel buffer channel chunk_size; true with End_of_file -> false then add_channel_to_the_end ~chunk_size buffer channel let input_all channel = let chunk_size = 65536 in let buffer_size = try in_channel_length channel - pos_in channel with Sys_error _ -> -1 in let buffer = Buffer.create buffer_size in add_channel_to_the_end ~chunk_size buffer channel; Buffer.contents buffer @END_BEFORE_4_14_0@ @BEGIN_BEFORE_5_1_0@ let rec fold_lines f acc ic = match input_line ic with | None -> acc | Some line -> fold_lines f (f acc line) ic let input_lines ic = List.rev (fold_lines (fun acc line -> line :: acc) [] ic) let isatty _ic = failwith "not implemented" @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__in_channel.mli.in000066400000000000000000000000421463722102200235340ustar00rootroot00000000000000include Stdcompat__in_channel_s.S ocaml-stdcompat-20~git20240529/stdcompat__in_channel_s.mli.in000066400000000000000000000100371463722102200240630ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_14_0@ type t = in_channel @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type t = in_channel @END_BEFORE_4_14_0@ (** @since 4.14.0: type t = in_channel *) @BEGIN_FROM_4_14_0@ type open_flag = In_channel.open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock @END_BEFORE_4_14_0@ (** @since 4.14.0: type open_flag = In_channel.open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock *) val input_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> int (** @since 5.2.0: val input_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> int *) val really_input_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> unit option (** @since 5.2.0: val really_input_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> unit option *) val is_binary_mode : t -> bool (** @since 5.2.0: val is_binary_mode : t -> bool *) val input_lines : t -> string list (** @since 5.1.0: val input_lines : t -> string list *) val fold_lines : ('acc -> string -> 'acc) -> 'acc -> t -> 'acc (** @since 5.1.0: val fold_lines : ('acc -> string -> 'acc) -> 'acc -> t -> 'acc *) val isatty : t -> bool (** @since 5.1.0: val isatty : t -> bool *) val stdin : t (** @since 4.14.0: val stdin : t *) val open_bin : string -> t (** @since 4.14.0: val open_bin : string -> t *) val open_text : string -> t (** @since 4.14.0: val open_text : string -> t *) val open_gen : open_flag list -> int -> string -> t (** @since 4.14.0: val open_gen : open_flag list -> int -> string -> t *) val with_open_bin : string -> (t -> 'a) -> 'a (** @since 4.14.0: val with_open_bin : string -> (t -> 'a) -> 'a *) val with_open_text : string -> (t -> 'a) -> 'a (** @since 4.14.0: val with_open_text : string -> (t -> 'a) -> 'a *) val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a (** @since 4.14.0: val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a *) val close : t -> unit (** @since 4.14.0: val close : t -> unit *) val close_noerr : t -> unit (** @since 4.14.0: val close_noerr : t -> unit *) val input_char : t -> char option (** @since 4.14.0: val input_char : t -> char option *) val input_byte : t -> int option (** @since 4.14.0: val input_byte : t -> int option *) val input_line : t -> string option (** @since 4.14.0: val input_line : t -> string option *) val really_input_string : t -> int -> string option (** @since 4.14.0: val really_input_string : t -> int -> string option *) val input_all : t -> string (** @since 4.14.0: val input_all : t -> string *) @BEGIN_FROM_4_14_0@ val input : t -> bytes -> int -> int -> int @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val input : t -> Stdcompat__init.bytes -> int -> int -> int @END_BEFORE_4_14_0@ (** @since 4.14.0: val input : t -> bytes -> int -> int -> int *) @BEGIN_FROM_4_14_0@ val really_input : t -> bytes -> int -> int -> unit option @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val really_input : t -> Stdcompat__init.bytes -> int -> int -> unit option @END_BEFORE_4_14_0@ (** @since 4.14.0: val really_input : t -> bytes -> int -> int -> unit option *) val seek : t -> int64 -> unit (** @since 4.14.0: val seek : t -> int64 -> unit *) val pos : t -> int64 (** @since 4.14.0: val pos : t -> int64 *) val length : t -> int64 (** @since 4.14.0: val length : t -> int64 *) val set_binary_mode : t -> bool -> unit (** @since 4.14.0: val set_binary_mode : t -> bool -> unit *) end ocaml-stdcompat-20~git20240529/stdcompat__init.mli.in000066400000000000000000000034741463722102200224150ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ type 'a lazy_t = 'a CamlinternalLazy.t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a lazy_t_ = 'a lazy_t type 'a lazy_t = 'a lazy_t_ @END_BEFORE_4_08_0@ type in_channel_ = in_channel type in_channel = in_channel_ type out_channel_ = out_channel type out_channel = out_channel_ @BEGIN_FROM_4_06_0@ type nonrec floatarray = floatarray type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ type floatarray = float array @BEGIN_FROM_3_10_0@ type ('a, 'b, 'c, 'd, 'e, 'f) format6_ = ('a, 'b, 'c, 'd, 'e, 'f) format6 type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) format6_ @END_FROM_3_10_0@ @BEGIN_BEFORE_3_10_0@ type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'f) format4 @END_BEFORE_3_10_0@ @END_BEFORE_4_06_0@ @BEGIN_FROM_4_02_0@ type nonrec bytes = bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type bytes = string @END_BEFORE_4_02_0@ type ('a, 'b) result = @BEGIN_FROM_4_07_0@ ('a, 'b) Stdlib.result = @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ @BEGIN_FROM_4_03_0@ ('a, 'b) Pervasives.result = @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_RESULT_PKG@ ('a, 'b) Result.result = @END_WITH_RESULT_PKG@ @END_BEFORE_4_03_0@ @END_BEFORE_4_07_0@ | Ok of 'a | Error of 'b @BEGIN_FROM_4_07_0@ type 'a seq = unit -> 'a seq_node and 'a seq_node = 'a Seq.node = | Nil | Cons of 'a * 'a seq @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ type 'a seq = unit -> 'a seq_node and 'a seq_node = @BEGIN_WITH_SEQ_PKG@ 'a Seq.node = @END_WITH_SEQ_PKG@ | Nil | Cons of 'a * 'a seq @END_BEFORE_4_07_0@ @BEGIN_FROM_4_12_0@ type ('a, 'b) either = ('a, 'b) Either.t = | Left of 'a | Right of 'b @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type ('a, 'b) either = | Left of 'a | Right of 'b @END_BEFORE_4_12_0@ ocaml-stdcompat-20~git20240529/stdcompat__int.ml.in000066400000000000000000000020241463722102200220610ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type t = int let zero = 0 let one = 1 let minus_one = -1 external neg : int -> int = "%negint" external add : int -> int -> int = "%addint" external sub : int -> int -> int = "%subint" external mul : int -> int -> int = "%mulint" external div : int -> int -> int = "%divint" external rem : int -> int -> int = "%modint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" let abs = abs let max_int = max_int let min_int = min_int external logand : int -> int -> int = "%andint" external logor : int -> int -> int = "%orint" external logxor : int -> int -> int = "%xorint" let lognot = lnot external shift_left : int -> int -> int = "%lslint" external shift_right : int -> int -> int = "%asrint" external shift_right_logical : int -> int -> int = "%lsrint" let equal = ( = ) let compare = compare external to_float : int -> float = "%floatofint" external of_float : float -> int = "%intoffloat" let to_string = string_of_int @END_BEFORE_4_08_0@ ocaml-stdcompat-20~git20240529/stdcompat__int.mli.in000066400000000000000000000000331463722102200222300ustar00rootroot00000000000000include Stdcompat__int_s.S ocaml-stdcompat-20~git20240529/stdcompat__int32.ml.in000066400000000000000000000053621463722102200222360ustar00rootroot00000000000000include Int32 @BEGIN_BEFORE_4_13_0@ let min i j = if compare i j >= 0 then j else i let max i j = if compare i j >= 0 then i else j @END_BEFORE_4_13_0@ @BEGIN_BEFORE_4_08_0@ let unsigned_compare i j = compare (sub i min_int) (sub j min_int) let unsigned_to_int = let max_int = of_int Stdcompat__pervasives.max_int in fun i -> if compare zero i <= 0 && compare i max_int <= 0 then Some (to_int i) else None (* Unsigned division from signed division of the same bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3. *) let unsigned_div n d = if d < zero then if unsigned_compare n d < 0 then zero else one else let q = shift_left (div (shift_right_logical n 1) d) 1 in let r = sub n (mul q d) in if unsigned_compare r d >= 0 then succ q else q let unsigned_rem n d = sub n (mul (unsigned_div n d) d) @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_03_0@ let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ let of_string_opt s = Stdcompat__tools.option_fail of_string s @END_BEFORE_4_05_0@ @BEGIN_BEFORE_3_08_0@ let float_of_bits bits = let sign = not (equal (shift_right_logical bits 31) zero) in let exponent32 = to_int (shift_right_logical bits 23) land (1 lsl 8 - 1) in let int32_2power23minus1 = sub (shift_left one 23) one in let mantissa32 = logand bits int32_2power23minus1 in let mantissa64 = Int64.shift_left (Int64.of_int32 mantissa32) 29 in let exponent64 = exponent32 + 1023 - 127 in let unsigned = Int64.logor (Int64.shift_left (Int64.of_int exponent64) 52) mantissa64 in let signed = if sign then Int64.logor (Int64.shift_left Int64.one 63) unsigned else unsigned in Int64.float_of_bits signed let bits_of_float f = let bits = Int64.bits_of_float f in let sign = not (Stdcompat__int64.equal (Int64.shift_right_logical bits 63) Int64.zero) in let exponent64 = Int64.to_int (Int64.shift_right_logical bits 52) land (1 lsl 10 - 1) in let int64_2power52minus1 = Int64.sub (Int64.shift_left Int64.one 52) Int64.one in let mantissa64 = Int64.logand bits int64_2power52minus1 in let mantissa32_truncated = Int64.to_int32 (Int64.shift_right_logical mantissa64 29) in let mantissa32 = if Stdcompat__int64.equal (Int64.logand (Int64.shift_right_logical bits 28) Int64.one) Int64.zero then mantissa32_truncated else add mantissa32_truncated one in let exponent32 = exponent64 + 127 - 1023 in let unsigned = logor (shift_left (of_int exponent32) 23) mantissa32 in if sign then logor (shift_left one 31) unsigned else unsigned @END_BEFORE_3_08_0@ @BEGIN_BEFORE_5_1_0@ let hash = Hashtbl.hash let seeded_hash = Stdcompat__hashtbl.seeded_hash @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__int32.mli.in000066400000000000000000000000351463722102200223770ustar00rootroot00000000000000include Stdcompat__int32_s.S ocaml-stdcompat-20~git20240529/stdcompat__int32_s.mli.in000066400000000000000000000133661463722102200227340ustar00rootroot00000000000000module type S = sig type t = int32 (** Alias for {!Int32.t} *) val seeded_hash : int -> t -> int (** @since 5.1.0: val seeded_hash : int -> t -> int *) val hash : t -> int (** @since 5.1.0: val hash : t -> int *) val min : t -> t -> t (** @since 4.13.0: val min : t -> t -> t *) val max : t -> t -> t (** @since 4.13.0: val max : t -> t -> t *) val unsigned_div : int32 -> int32 -> int32 (** @since 4.08.0: val unsigned_div : int32 -> int32 -> int32 *) val unsigned_rem : int32 -> int32 -> int32 (** @since 4.08.0: val unsigned_rem : int32 -> int32 -> int32 *) val unsigned_to_int : int32 -> int option (** @since 4.08.0: val unsigned_to_int : int32 -> int option *) val unsigned_compare : t -> t -> int (** @since 4.08.0: val unsigned_compare : t -> t -> int *) val of_string_opt : string -> int32 option (** @since 4.05.0: val of_string_opt : string -> int32 option *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) @BEGIN_FROM_4_03_0@ external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external bits_of_float : float -> int32 = "caml_int32_bits_of_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ val bits_of_float : float -> int32 @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external bits_of_float : float -> int32 = "caml_int32_bits_of_float" "caml_int32_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] @since 3.08.0: external bits_of_float : float -> int32 = "caml_int32_bits_of_float" *) @BEGIN_FROM_4_03_0@ external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external float_of_bits : int32 -> float = "caml_int32_float_of_bits" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ val float_of_bits : int32 -> float @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external float_of_bits : int32 -> float = "caml_int32_float_of_bits" "caml_int32_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] @since 3.08.0: external float_of_bits : int32 -> float = "caml_int32_float_of_bits" *) val zero : int32 (** Alias for {!Int32.zero} *) val one : int32 (** Alias for {!Int32.one} *) val minus_one : int32 (** Alias for {!Int32.minus_one} *) external neg : int32 -> int32 = "%int32_neg" (** Alias for {!Int32.neg} *) external add : int32 -> int32 -> int32 = "%int32_add" (** Alias for {!Int32.add} *) external sub : int32 -> int32 -> int32 = "%int32_sub" (** Alias for {!Int32.sub} *) external mul : int32 -> int32 -> int32 = "%int32_mul" (** Alias for {!Int32.mul} *) external div : int32 -> int32 -> int32 = "%int32_div" (** Alias for {!Int32.div} *) external rem : int32 -> int32 -> int32 = "%int32_mod" (** Alias for {!Int32.rem} *) val succ : int32 -> int32 (** Alias for {!Int32.succ} *) val pred : int32 -> int32 (** Alias for {!Int32.pred} *) val abs : int32 -> int32 (** Alias for {!Int32.abs} *) val max_int : int32 (** Alias for {!Int32.max_int} *) val min_int : int32 (** Alias for {!Int32.min_int} *) external logand : int32 -> int32 -> int32 = "%int32_and" (** Alias for {!Int32.logand} *) external logor : int32 -> int32 -> int32 = "%int32_or" (** Alias for {!Int32.logor} *) external logxor : int32 -> int32 -> int32 = "%int32_xor" (** Alias for {!Int32.logxor} *) val lognot : int32 -> int32 (** Alias for {!Int32.lognot} *) external shift_left : int32 -> int -> int32 = "%int32_lsl" (** Alias for {!Int32.shift_left} *) external shift_right : int32 -> int -> int32 = "%int32_asr" (** Alias for {!Int32.shift_right} *) external shift_right_logical : int32 -> int -> int32 = "%int32_lsr" (** Alias for {!Int32.shift_right_logical} *) external of_int : int -> int32 = "%int32_of_int" (** Alias for {!Int32.of_int} *) external to_int : int32 -> int = "%int32_to_int" (** Alias for {!Int32.to_int} *) @BEGIN_FROM_4_03_0@ external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external of_float : float -> int32 = "caml_int32_of_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_float : float -> int32 = "int32_of_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external of_float : float -> int32 = "caml_int32_of_float" "caml_int32_of_float_unboxed" [@@unboxed ][@@noalloc ] @since 3.08.0: external of_float : float -> int32 = "caml_int32_of_float" @since 3.07.0: external of_float : float -> int32 = "int32_of_float" *) @BEGIN_FROM_4_03_0@ external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external to_float : int32 -> float = "caml_int32_to_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external to_float : int32 -> float = "int32_to_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external to_float : int32 -> float = "caml_int32_to_float" "caml_int32_to_float_unboxed" [@@unboxed ][@@noalloc ] @since 3.08.0: external to_float : int32 -> float = "caml_int32_to_float" @since 3.07.0: external to_float : int32 -> float = "int32_to_float" *) @BEGIN_FROM_3_08_0@ external of_string : string -> int32 = "caml_int32_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_string : string -> int32 = "int32_of_string" @END_BEFORE_3_08_0@ (** @since 3.08.0: external of_string : string -> int32 = "caml_int32_of_string" @since 3.07.0: external of_string : string -> int32 = "int32_of_string" *) val to_string : int32 -> string (** Alias for {!Int32.to_string} *) val compare : t -> t -> int (** Alias for {!Int32.compare} *) end ocaml-stdcompat-20~git20240529/stdcompat__int64.ml.in000066400000000000000000000022671463722102200222440ustar00rootroot00000000000000include Int64 @BEGIN_BEFORE_4_13_0@ let min i j = if compare i j >= 0 then j else i let max i j = if compare i j >= 0 then i else j @END_BEFORE_4_13_0@ @BEGIN_BEFORE_4_08_0@ let unsigned_compare i j = compare (sub i min_int) (sub j min_int) let unsigned_to_int = let max_int = of_int Stdcompat__pervasives.max_int in fun i -> if compare zero i <= 0 && compare i max_int <= 0 then Some (to_int i) else None (* Unsigned division from signed division of the same bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3. *) let unsigned_div n d = if d < zero then if unsigned_compare n d < 0 then zero else one else let q = shift_left (div (shift_right_logical n 1) d) 1 in let r = sub n (mul q d) in if unsigned_compare r d >= 0 then succ q else q let unsigned_rem n d = sub n (mul (unsigned_div n d) d) @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_03_0@ let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ let of_string_opt s = Stdcompat__tools.option_fail of_string s @END_BEFORE_4_05_0@ @BEGIN_BEFORE_5_1_0@ let hash = Hashtbl.hash let seeded_hash = Stdcompat__hashtbl.seeded_hash @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__int64.mli.in000066400000000000000000000000351463722102200224040ustar00rootroot00000000000000include Stdcompat__int64_s.S ocaml-stdcompat-20~git20240529/stdcompat__int64_s.mli.in000066400000000000000000000145321463722102200227350ustar00rootroot00000000000000module type S = sig type t = int64 (** Alias for {!Int64.t} *) val seeded_hash : int -> t -> int (** @since 5.1.0: val seeded_hash : int -> t -> int *) val hash : t -> int (** @since 5.1.0: val hash : t -> int *) val min : t -> t -> t (** @since 4.13.0: val min : t -> t -> t *) val max : t -> t -> t (** @since 4.13.0: val max : t -> t -> t *) val unsigned_div : int64 -> int64 -> int64 (** @since 4.08.0: val unsigned_div : int64 -> int64 -> int64 *) val unsigned_rem : int64 -> int64 -> int64 (** @since 4.08.0: val unsigned_rem : int64 -> int64 -> int64 *) val unsigned_to_int : int64 -> int option (** @since 4.08.0: val unsigned_to_int : int64 -> int option *) val unsigned_compare : t -> t -> int (** @since 4.08.0: val unsigned_compare : t -> t -> int *) val of_string_opt : string -> int64 option (** @since 4.05.0: val of_string_opt : string -> int64 option *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) val zero : int64 (** Alias for {!Int64.zero} *) val one : int64 (** Alias for {!Int64.one} *) val minus_one : int64 (** Alias for {!Int64.minus_one} *) external neg : int64 -> int64 = "%int64_neg" (** Alias for {!Int64.neg} *) external add : int64 -> int64 -> int64 = "%int64_add" (** Alias for {!Int64.add} *) external sub : int64 -> int64 -> int64 = "%int64_sub" (** Alias for {!Int64.sub} *) external mul : int64 -> int64 -> int64 = "%int64_mul" (** Alias for {!Int64.mul} *) external div : int64 -> int64 -> int64 = "%int64_div" (** Alias for {!Int64.div} *) external rem : int64 -> int64 -> int64 = "%int64_mod" (** Alias for {!Int64.rem} *) val succ : int64 -> int64 (** Alias for {!Int64.succ} *) val pred : int64 -> int64 (** Alias for {!Int64.pred} *) val abs : int64 -> int64 (** Alias for {!Int64.abs} *) val max_int : int64 (** Alias for {!Int64.max_int} *) val min_int : int64 (** Alias for {!Int64.min_int} *) external logand : int64 -> int64 -> int64 = "%int64_and" (** Alias for {!Int64.logand} *) external logor : int64 -> int64 -> int64 = "%int64_or" (** Alias for {!Int64.logor} *) external logxor : int64 -> int64 -> int64 = "%int64_xor" (** Alias for {!Int64.logxor} *) val lognot : int64 -> int64 (** Alias for {!Int64.lognot} *) external shift_left : int64 -> int -> int64 = "%int64_lsl" (** Alias for {!Int64.shift_left} *) external shift_right : int64 -> int -> int64 = "%int64_asr" (** Alias for {!Int64.shift_right} *) external shift_right_logical : int64 -> int -> int64 = "%int64_lsr" (** Alias for {!Int64.shift_right_logical} *) external of_int : int -> int64 = "%int64_of_int" (** Alias for {!Int64.of_int} *) external to_int : int64 -> int = "%int64_to_int" (** Alias for {!Int64.to_int} *) @BEGIN_FROM_4_03_0@ external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external of_float : float -> int64 = "caml_int64_of_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_float : float -> int64 = "int64_of_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external of_float : float -> int64 = "caml_int64_of_float" "caml_int64_of_float_unboxed" [@@unboxed ][@@noalloc ] @since 3.08.0: external of_float : float -> int64 = "caml_int64_of_float" @since 3.07.0: external of_float : float -> int64 = "int64_of_float" *) @BEGIN_FROM_4_03_0@ external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external to_float : int64 -> float = "caml_int64_to_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external to_float : int64 -> float = "int64_to_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external to_float : int64 -> float = "caml_int64_to_float" "caml_int64_to_float_unboxed" [@@unboxed ][@@noalloc ] @since 3.08.0: external to_float : int64 -> float = "caml_int64_to_float" @since 3.07.0: external to_float : int64 -> float = "int64_to_float" *) external of_int32 : int32 -> int64 = "%int64_of_int32" (** Alias for {!Int64.of_int32} *) external to_int32 : int64 -> int32 = "%int64_to_int32" (** Alias for {!Int64.to_int32} *) external of_nativeint : nativeint -> int64 = "%int64_of_nativeint" (** Alias for {!Int64.of_nativeint} *) external to_nativeint : int64 -> nativeint = "%int64_to_nativeint" (** Alias for {!Int64.to_nativeint} *) @BEGIN_FROM_3_08_0@ external of_string : string -> int64 = "caml_int64_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_string : string -> int64 = "int64_of_string" @END_BEFORE_3_08_0@ (** @since 3.08.0: external of_string : string -> int64 = "caml_int64_of_string" @since 3.07.0: external of_string : string -> int64 = "int64_of_string" *) val to_string : int64 -> string (** Alias for {!Int64.to_string} *) @BEGIN_FROM_4_03_0@ external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external bits_of_float : float -> int64 = "caml_int64_bits_of_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external bits_of_float : float -> int64 = "int64_bits_of_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external bits_of_float : float -> int64 = "caml_int64_bits_of_float" "caml_int64_bits_of_float_unboxed"[@@unboxed ][@@noalloc ] @since 3.08.0: external bits_of_float : float -> int64 = "caml_int64_bits_of_float" @since 3.07.0: external bits_of_float : float -> int64 = "int64_bits_of_float" *) @BEGIN_FROM_4_03_0@ external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external float_of_bits : int64 -> float = "caml_int64_float_of_bits" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external float_of_bits : int64 -> float = "int64_float_of_bits" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external float_of_bits : int64 -> float = "caml_int64_float_of_bits" "caml_int64_float_of_bits_unboxed"[@@unboxed ][@@noalloc ] @since 3.08.0: external float_of_bits : int64 -> float = "caml_int64_float_of_bits" @since 3.07.0: external float_of_bits : int64 -> float = "int64_float_of_bits" *) val compare : t -> t -> int (** Alias for {!Int64.compare} *) end ocaml-stdcompat-20~git20240529/stdcompat__int_s.mli.in000066400000000000000000000020471463722102200225610ustar00rootroot00000000000000module type S = sig type t = int val zero : int val one : int val minus_one : int external neg : int -> int = "%negint" external add : int -> int -> int = "%addint" external sub : int -> int -> int = "%subint" external mul : int -> int -> int = "%mulint" external div : int -> int -> int = "%divint" external rem : int -> int -> int = "%modint" external succ : int -> int = "%succint" external pred : int -> int = "%predint" val abs : int -> int val max_int : int val min_int : int external logand : int -> int -> int = "%andint" external logor : int -> int -> int = "%orint" external logxor : int -> int -> int = "%xorint" val lognot : int -> int external shift_left : int -> int -> int = "%lslint" external shift_right : int -> int -> int = "%asrint" external shift_right_logical : int -> int -> int = "%lsrint" val equal : int -> int -> bool val compare : int -> int -> int external to_float : int -> float = "%floatofint" external of_float : float -> int = "%intoffloat" val to_string : int -> string end ocaml-stdcompat-20~git20240529/stdcompat__lazy.ml.in000066400000000000000000000004571463722102200222560ustar00rootroot00000000000000include Lazy @BEGIN_BEFORE_4_00_0@ let from_fun = lazy_from_fun let from_val = lazy_from_val let is_val = lazy_is_val @END_BEFORE_4_00_0@ @BEGIN_BEFORE_4_13_0@ let map f v = lazy (f (force v)) let map_val f v = if is_val v then from_val (f (force v)) else map f v @END_BEFORE_4_13_0@ ocaml-stdcompat-20~git20240529/stdcompat__lazy.mli.in000066400000000000000000000000341463722102200224160ustar00rootroot00000000000000include Stdcompat__lazy_s.S ocaml-stdcompat-20~git20240529/stdcompat__lazy_s.mli.in000066400000000000000000000020361463722102200227440ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type 'a t = 'a CamlinternalLazy.t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a Stdcompat__init.lazy_t @END_BEFORE_4_08_0@ (** @since 4.08.0: type 'a t = 'a CamlinternalLazy.t *) exception Undefined (** Alias for {!Lazy.Undefined} *) val map : ('a -> 'b) -> 'a t -> 'b t (** @since 4.13.0: val map : ('a -> 'b) -> 'a t -> 'b t *) val map_val : ('a -> 'b) -> 'a t -> 'b t (** @since 4.13.0: val map_val : ('a -> 'b) -> 'a t -> 'b t *) val is_val : 'a t -> bool (** @since 4.00.0: val is_val : 'a t -> bool *) val from_val : 'a -> 'a t (** @since 4.00.0: val from_val : 'a -> 'a t *) val from_fun : (unit -> 'a) -> 'a t (** @since 4.00.0: val from_fun : (unit -> 'a) -> 'a t *) @BEGIN_FROM_3_11_0@ external force : 'a t -> 'a = "%lazy_force" @END_FROM_3_11_0@ @BEGIN_BEFORE_3_11_0@ val force : 'a t -> 'a @END_BEFORE_3_11_0@ (** @since 3.11.0: external force : 'a t -> 'a = "%lazy_force" @since 3.07.0: val force : 'a t -> 'a *) val force_val : 'a t -> 'a (** Alias for {!Lazy.force_val} *) end ocaml-stdcompat-20~git20240529/stdcompat__lexing.ml.in000066400000000000000000000016121463722102200225570ustar00rootroot00000000000000include Lexing @BEGIN_BEFORE_4_11_0@ let set_position lexbuf position = lexbuf.lex_curr_p <- { position with pos_fname = lexbuf.lex_curr_p.pos_fname }; lexbuf.lex_abs_pos <- position.pos_cnum let set_filename lexbuf filename = lexbuf.lex_curr_p <- { lexbuf.lex_curr_p with pos_fname = filename } @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_08_0@ let from_channel ?with_positions:_pos chan = from_channel chan let from_string ?with_positions:_pos s = from_string s let from_function ?with_positions:_pos f = from_function f let with_positions _lexbuf = true @END_BEFORE_4_08_0@ @BEGIN_BEFORE_3_11_0@ let new_line lexbuf = let lex_curr_p = lexbuf.Lexing.lex_curr_p in if lex_curr_p != Lexing.dummy_pos then lexbuf.Lexing.lex_curr_p <- { lex_curr_p with Lexing.pos_lnum = succ lex_curr_p.Lexing.pos_lnum; Lexing.pos_bol = lex_curr_p.Lexing.pos_cnum; } @END_BEFORE_3_11_0@ ocaml-stdcompat-20~git20240529/stdcompat__lexing.mli.in000066400000000000000000000000361463722102200227270ustar00rootroot00000000000000include Stdcompat__lexing_s.S ocaml-stdcompat-20~git20240529/stdcompat__lexing_s.mli.in000066400000000000000000000106551463722102200232610ustar00rootroot00000000000000module type S = sig type position = Lexing.position = { pos_fname: string ; pos_lnum: int ; pos_bol: int ; pos_cnum: int } (** Alias for {!Lexing.position} *) @BEGIN_FROM_4_02_0@ type lexbuf = Lexing.lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type lexbuf = Lexing.lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } @END_BEFORE_4_02_0@ (** @since 4.02.0: type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: bytes ; mutable lex_buffer_len: int ; mutable lex_abs_pos: int ; mutable lex_start_pos: int ; mutable lex_curr_pos: int ; mutable lex_last_pos: int ; mutable lex_last_action: int ; mutable lex_eof_reached: bool ; mutable lex_mem: int array ; mutable lex_start_p: position ; mutable lex_curr_p: position } @since 3.07.0: type lexbuf = { refill_buff: lexbuf -> unit ; mutable lex_buffer: string ; 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 } *) type lex_tables = Lexing.lex_tables = { lex_base: string ; lex_backtrk: string ; lex_default: string ; lex_trans: string ; lex_check: string ; lex_base_code: string ; lex_backtrk_code: string ; lex_default_code: string ; lex_trans_code: string ; lex_check_code: string ; lex_code: string } (** Alias for {!Lexing.lex_tables} *) val set_position : lexbuf -> position -> unit (** @since 4.11.0: val set_position : lexbuf -> position -> unit *) val set_filename : lexbuf -> string -> unit (** @since 4.11.0: val set_filename : lexbuf -> string -> unit *) val from_channel : ?with_positions:bool -> in_channel -> lexbuf (** @since 4.08.0: val from_channel : ?with_positions:bool -> in_channel -> lexbuf *) val from_string : ?with_positions:bool -> string -> lexbuf (** @since 4.08.0: val from_string : ?with_positions:bool -> string -> lexbuf *) @BEGIN_FROM_4_08_0@ val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val from_function : ?with_positions:bool -> (Stdcompat__init.bytes -> int -> int) -> lexbuf @END_BEFORE_4_08_0@ (** @since 4.08.0: val from_function : ?with_positions:bool -> (bytes -> int -> int) -> lexbuf *) val with_positions : lexbuf -> bool (** @since 4.08.0: val with_positions : lexbuf -> bool *) val new_line : lexbuf -> unit (** @since 3.11.0: val new_line : lexbuf -> unit *) val dummy_pos : position (** Alias for {!Lexing.dummy_pos} *) val lexeme : lexbuf -> string (** Alias for {!Lexing.lexeme} *) val lexeme_char : lexbuf -> int -> char (** Alias for {!Lexing.lexeme_char} *) val lexeme_start : lexbuf -> int (** Alias for {!Lexing.lexeme_start} *) val lexeme_end : lexbuf -> int (** Alias for {!Lexing.lexeme_end} *) val lexeme_start_p : lexbuf -> position (** Alias for {!Lexing.lexeme_start_p} *) val lexeme_end_p : lexbuf -> position (** Alias for {!Lexing.lexeme_end_p} *) val flush_input : lexbuf -> unit (** Alias for {!Lexing.flush_input} *) val sub_lexeme : lexbuf -> int -> int -> string (** Alias for {!Lexing.sub_lexeme} *) val sub_lexeme_opt : lexbuf -> int -> int -> string option (** Alias for {!Lexing.sub_lexeme_opt} *) val sub_lexeme_char : lexbuf -> int -> char (** Alias for {!Lexing.sub_lexeme_char} *) val sub_lexeme_char_opt : lexbuf -> int -> char option (** Alias for {!Lexing.sub_lexeme_char_opt} *) val engine : lex_tables -> int -> lexbuf -> int (** Alias for {!Lexing.engine} *) val new_engine : lex_tables -> int -> lexbuf -> int (** Alias for {!Lexing.new_engine} *) end ocaml-stdcompat-20~git20240529/stdcompat__list.ml.in000066400000000000000000000105501463722102200222450ustar00rootroot00000000000000include List @BEGIN_BEFORE_4_08_0@ type 'a t = 'a list @BEGIN_FROM_4_03_0@ = [] | (::) of 'a * 'a list @END_FROM_4_03_0@ let filter_map f list = let rec aux accu list = match list with | [] -> rev accu | head :: tail -> let accu' = match f head with | None -> accu | Some head' -> head' :: accu in aux accu' tail in aux [] list @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_12_0@ let rec partition_map_aux left right f list = match list with | [] -> rev left, rev right | hd :: tl -> match f hd with | Stdcompat__either.Left v -> partition_map_aux (v :: left) right f tl | Stdcompat__either.Right v -> partition_map_aux left (v :: right) f tl let partition_map f list = partition_map_aux [] [] f list let rec compare cmp l0 l1 = match l0, l1 with | [], [] -> 0 | [], _ :: _ -> -1 | _ :: _, [] -> 1 | hd0 :: tl0, hd1 :: tl1 -> match cmp hd0 hd1 with | 0 -> compare cmp tl0 tl1 | c -> c let rec equal eq l0 l1 = match l0, l1 with | [], [] -> true | [], _ :: _ | _ :: _, [] -> false | hd0 :: tl0, hd1 :: tl1 -> eq hd0 hd1 && equal eq tl0 tl1 @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_00_0@ let rec iteri_aux i f l = match l with | [] -> () | hd :: tl -> f i hd; iteri_aux (succ i) f tl let iteri f l = iteri_aux 0 f l let rec mapi_aux i f l = match l with | [] -> [] | hd :: tl -> let hd = f i hd in hd :: mapi_aux (succ i) f tl let mapi f l = mapi_aux 0 f l @END_BEFORE_4_00_0@ @BEGIN_BEFORE_4_02_0@ let sort_uniq cmp l = let cmp' a b = - (cmp a b) in let rev_l = sort cmp' l in Stdcompat__tools.uniq_rev_append cmp rev_l [] @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_03_0@ let cons x xs = x :: xs @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ let rec compare_lengths l l' = match l, l' with | [], [] -> 0 | [], _ -> -1 | _, [] -> 1 | _ :: tl, _ :: tl' -> compare_lengths tl tl' let rec compare_length_with l n = if n < 0 then 1 else if n = 0 then if l = [] then 0 else 1 else match l with | [] -> -1 | _ :: tl -> compare_length_with tl (pred n) let nth_opt l n = Stdcompat__tools.option_fail (nth l) n let find_opt p l = try Stdcompat__tools.option_find (find (Stdcompat__tools.pickle_predicate_not_found p)) l with Stdcompat__tools.Predicate_not_found -> raise Not_found let assoc_opt key l = Stdcompat__tools.option_find (assoc key) l let assq_opt key l= Stdcompat__tools.option_find (assq key) l @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_06_0@ let rec init_aux i len f accu = if i >= len then accu else init_aux (succ i) len f (f i :: accu) let init len f = if len < 0 then invalid_arg "List.init" else if len = 0 then [] else rev (init_aux 0 len f []) @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_07_0@ let of_seq seq = rev (Stdcompat__seq.fold_left (fun accu x -> x :: accu) [] seq) let rec to_seq l () = match l with | [] -> Stdcompat__seq.Nil | hd :: tl -> Stdcompat__seq.Cons (hd, to_seq tl) @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_10_0@ let rec find_map f l = match l with | [] -> None | hd :: tl -> match f hd with | None -> find_map f tl | some -> some let rec concat_rev_map_aux f l accu = match l with | [] -> accu | hd :: tl -> concat_rev_map_aux f tl (rev_append (f hd) accu) let concat_map f l = rev (concat_rev_map_aux f l []) @END_BEFORE_4_10_0@ @BEGIN_BEFORE_4_11_0@ let rec filteri_rev_aux f l i accu = match l with | [] -> accu | hd :: tl -> let accu = if f i hd then hd :: accu else accu in filteri_rev_aux f tl (succ i) accu let filteri f l = rev (filteri_rev_aux f l 0 []) let fold_left_map f accu l = let accu, rev = fold_left (fun (accu, rev) item -> let accu, x = f accu item in (accu, x :: rev)) (accu, []) l in accu, List.rev rev @END_BEFORE_4_11_0@ @BEGIN_BEFORE_5_1_0@ let is_empty l = l = [] let rec find_index_from index p l = match l with | [] -> None | hd :: tl -> if p hd then Some index else find_index_from (succ index) p tl let find_index p l = find_index_from 0 p l let rec find_mapi_from index f l = match l with | [] -> None | hd :: tl -> match f index hd with | None -> find_mapi_from (succ index) f tl | some -> some let find_mapi f l = find_mapi_from 0 f l @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__list.mli.in000066400000000000000000000000341463722102200224120ustar00rootroot00000000000000include Stdcompat__list_s.S ocaml-stdcompat-20~git20240529/stdcompat__listLabels.ml.in000066400000000000000000000000301463722102200233600ustar00rootroot00000000000000include Stdcompat__list ocaml-stdcompat-20~git20240529/stdcompat__listLabels.mli.in000066400000000000000000000000421463722102200235340ustar00rootroot00000000000000include Stdcompat__listLabels_s.S ocaml-stdcompat-20~git20240529/stdcompat__listLabels_s.mli.in000066400000000000000000000225171463722102200240710ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ @BEGIN_FROM_4_03_0@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ type 'a t = 'a list @END_BEFORE_4_03_0@ @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ type 'a t = 'a list @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: type 'a t = 'a list = | [] | (::) of 'a * 'a list *) val is_empty : 'a list -> bool (** @since 5.1.0: val is_empty : 'a list -> bool *) val find_index : f:('a -> bool) -> 'a list -> int option (** @since 5.1.0: val find_index : f:('a -> bool) -> 'a list -> int option *) val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option (** @since 5.1.0: val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option *) val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool (** @since 4.12.0: val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool *) val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int (** @since 4.12.0: val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> int *) @BEGIN_FROM_4_12_0@ val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ val partition_map : f:('a -> ('b, 'c) Stdcompat__either.t) -> 'a list -> ('b list * 'c list) @END_BEFORE_4_12_0@ (** @since 4.12.0: val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) *) @BEGIN_FROM_5_1_0@ val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a list -> ('acc * 'b list) @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_11_0@ val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) @END_FROM_4_11_0@ @BEGIN_BEFORE_4_11_0@ val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a list -> ('acc * 'b list) @END_BEFORE_4_11_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left_map : f:('acc -> 'a -> ('acc * 'b)) -> init:'acc -> 'a list -> ('acc * 'b list) @since 4.11.0: val fold_left_map : f:('a -> 'b -> ('a * 'c)) -> init:'a -> 'b list -> ('a * 'c list) *) val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list (** @since 4.11.0: val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list *) val concat_map : f:('a -> 'b list) -> 'a list -> 'b list (** @since 4.10.0: val concat_map : f:('a -> 'b list) -> 'a list -> 'b list *) val find_map : f:('a -> 'b option) -> 'a list -> 'b option (** @since 4.10.0: val find_map : f:('a -> 'b option) -> 'a list -> 'b option *) val filter_map : f:('a -> 'b option) -> 'a list -> 'b list (** @since 4.08.0: val filter_map : f:('a -> 'b option) -> 'a list -> 'b list *) @BEGIN_FROM_4_07_0@ val to_seq : 'a list -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a list -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : 'a list -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a list @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a list @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : 'a Seq.t -> 'a list *) val init : len:int -> f:(int -> 'a) -> 'a list (** @since 4.06.0: val init : len:int -> f:(int -> 'a) -> 'a list *) val compare_lengths : 'a list -> 'b list -> int (** @since 4.05.0: val compare_lengths : 'a list -> 'b list -> int *) val compare_length_with : 'a list -> len:int -> int (** @since 4.05.0: val compare_length_with : 'a list -> len:int -> int *) val cons : 'a -> 'a list -> 'a list (** @since 4.05.0: val cons : 'a -> 'a list -> 'a list *) val nth_opt : 'a list -> int -> 'a option (** @since 4.05.0: val nth_opt : 'a list -> int -> 'a option *) val find_opt : f:('a -> bool) -> 'a list -> 'a option (** @since 4.05.0: val find_opt : f:('a -> bool) -> 'a list -> 'a option *) val assoc_opt : 'a -> ('a * 'b) list -> 'b option (** @since 4.05.0: val assoc_opt : 'a -> ('a * 'b) list -> 'b option *) val assq_opt : 'a -> ('a * 'b) list -> 'b option (** @since 4.05.0: val assq_opt : 'a -> ('a * 'b) list -> 'b option *) val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** @since 4.03.0: val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list *) val iteri : f:(int -> 'a -> unit) -> 'a list -> unit (** @since 4.00.0: val iteri : f:(int -> 'a -> unit) -> 'a list -> unit *) val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list (** @since 4.00.0: val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list *) val length : 'a list -> int (** Alias for {!ListLabels.length} *) val hd : 'a list -> 'a (** Alias for {!ListLabels.hd} *) val tl : 'a list -> 'a list (** Alias for {!ListLabels.tl} *) val nth : 'a list -> int -> 'a (** Alias for {!ListLabels.nth} *) val rev : 'a list -> 'a list (** Alias for {!ListLabels.rev} *) val append : 'a list -> 'a list -> 'a list (** Alias for {!ListLabels.append} *) val rev_append : 'a list -> 'a list -> 'a list (** Alias for {!ListLabels.rev_append} *) val concat : 'a list list -> 'a list (** Alias for {!ListLabels.concat} *) val flatten : 'a list list -> 'a list (** Alias for {!ListLabels.flatten} *) val iter : f:('a -> unit) -> 'a list -> unit (** Alias for {!ListLabels.iter} *) val map : f:('a -> 'b) -> 'a list -> 'b list (** Alias for {!ListLabels.map} *) val rev_map : f:('a -> 'b) -> 'a list -> 'b list (** Alias for {!ListLabels.rev_map} *) @BEGIN_FROM_5_1_0@ val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc @since 3.07.0: val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'acc @since 3.07.0: val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b *) val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit (** Alias for {!ListLabels.iter2} *) val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** Alias for {!ListLabels.map2} *) val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** Alias for {!ListLabels.rev_map2} *) @BEGIN_FROM_5_1_0@ val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'acc @since 3.07.0: val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'acc @since 3.07.0: val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c *) val for_all : f:('a -> bool) -> 'a list -> bool (** Alias for {!ListLabels.for_all} *) val exists : f:('a -> bool) -> 'a list -> bool (** Alias for {!ListLabels.exists} *) val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!ListLabels.for_all2} *) val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!ListLabels.exists2} *) val mem : 'a -> set:'a list -> bool (** Alias for {!ListLabels.mem} *) val memq : 'a -> set:'a list -> bool (** Alias for {!ListLabels.memq} *) val find : f:('a -> bool) -> 'a list -> 'a (** Alias for {!ListLabels.find} *) val filter : f:('a -> bool) -> 'a list -> 'a list (** Alias for {!ListLabels.filter} *) val find_all : f:('a -> bool) -> 'a list -> 'a list (** Alias for {!ListLabels.find_all} *) val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) (** Alias for {!ListLabels.partition} *) val assoc : 'a -> ('a * 'b) list -> 'b (** Alias for {!ListLabels.assoc} *) val assq : 'a -> ('a * 'b) list -> 'b (** Alias for {!ListLabels.assq} *) val mem_assoc : 'a -> map:('a * 'b) list -> bool (** Alias for {!ListLabels.mem_assoc} *) val mem_assq : 'a -> map:('a * 'b) list -> bool (** Alias for {!ListLabels.mem_assq} *) val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!ListLabels.remove_assoc} *) val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!ListLabels.remove_assq} *) val split : ('a * 'b) list -> ('a list * 'b list) (** Alias for {!ListLabels.split} *) val combine : 'a list -> 'b list -> ('a * 'b) list (** Alias for {!ListLabels.combine} *) val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!ListLabels.sort} *) val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!ListLabels.stable_sort} *) val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!ListLabels.fast_sort} *) val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list (** Alias for {!ListLabels.merge} *) end ocaml-stdcompat-20~git20240529/stdcompat__list_s.mli.in000066400000000000000000000214721463722102200227450ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ @BEGIN_FROM_4_03_0@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ type 'a t = 'a list @END_BEFORE_4_03_0@ @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ type 'a t = 'a list @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: type 'a t = 'a list = | [] | (::) of 'a * 'a list *) val is_empty : 'a list -> bool (** @since 5.1.0: val is_empty : 'a list -> bool *) val find_index : ('a -> bool) -> 'a list -> int option (** @since 5.1.0: val find_index : ('a -> bool) -> 'a list -> int option *) val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option (** @since 5.1.0: val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option *) val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool (** @since 4.12.0: val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool *) val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int (** @since 4.12.0: val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int *) @BEGIN_FROM_4_12_0@ val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ val partition_map : ('a -> ('b, 'c) Stdcompat__either.t) -> 'a list -> ('b list * 'c list) @END_BEFORE_4_12_0@ (** @since 4.12.0: val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> ('b list * 'c list) *) @BEGIN_FROM_5_1_0@ val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a list -> ('acc * 'b list) @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_11_0@ val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) @END_FROM_4_11_0@ @BEGIN_BEFORE_4_11_0@ val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a list -> ('acc * 'b list) @END_BEFORE_4_11_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left_map : ('acc -> 'a -> ('acc * 'b)) -> 'acc -> 'a list -> ('acc * 'b list) @since 4.11.0: val fold_left_map : ('a -> 'b -> ('a * 'c)) -> 'a -> 'b list -> ('a * 'c list) *) val filteri : (int -> 'a -> bool) -> 'a list -> 'a list (** @since 4.11.0: val filteri : (int -> 'a -> bool) -> 'a list -> 'a list *) val concat_map : ('a -> 'b list) -> 'a list -> 'b list (** @since 4.10.0: val concat_map : ('a -> 'b list) -> 'a list -> 'b list *) val find_map : ('a -> 'b option) -> 'a list -> 'b option (** @since 4.10.0: val find_map : ('a -> 'b option) -> 'a list -> 'b option *) val filter_map : ('a -> 'b option) -> 'a list -> 'b list (** @since 4.08.0: val filter_map : ('a -> 'b option) -> 'a list -> 'b list *) @BEGIN_FROM_4_07_0@ val to_seq : 'a list -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a list -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : 'a list -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a list @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a list @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : 'a Seq.t -> 'a list *) val init : int -> (int -> 'a) -> 'a list (** @since 4.06.0: val init : int -> (int -> 'a) -> 'a list *) val compare_lengths : 'a list -> 'b list -> int (** @since 4.05.0: val compare_lengths : 'a list -> 'b list -> int *) val compare_length_with : 'a list -> int -> int (** @since 4.05.0: val compare_length_with : 'a list -> int -> int *) val nth_opt : 'a list -> int -> 'a option (** @since 4.05.0: val nth_opt : 'a list -> int -> 'a option *) val find_opt : ('a -> bool) -> 'a list -> 'a option (** @since 4.05.0: val find_opt : ('a -> bool) -> 'a list -> 'a option *) val assoc_opt : 'a -> ('a * 'b) list -> 'b option (** @since 4.05.0: val assoc_opt : 'a -> ('a * 'b) list -> 'b option *) val assq_opt : 'a -> ('a * 'b) list -> 'b option (** @since 4.05.0: val assq_opt : 'a -> ('a * 'b) list -> 'b option *) val cons : 'a -> 'a list -> 'a list (** @since 4.03.0: val cons : 'a -> 'a list -> 'a list *) val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list (** @since 4.02.0: val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list *) val iteri : (int -> 'a -> unit) -> 'a list -> unit (** @since 4.00.0: val iteri : (int -> 'a -> unit) -> 'a list -> unit *) val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list (** @since 4.00.0: val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list *) val length : 'a list -> int (** Alias for {!List.length} *) val hd : 'a list -> 'a (** Alias for {!List.hd} *) val tl : 'a list -> 'a list (** Alias for {!List.tl} *) val nth : 'a list -> int -> 'a (** Alias for {!List.nth} *) val rev : 'a list -> 'a list (** Alias for {!List.rev} *) val append : 'a list -> 'a list -> 'a list (** Alias for {!List.append} *) val rev_append : 'a list -> 'a list -> 'a list (** Alias for {!List.rev_append} *) val concat : 'a list list -> 'a list (** Alias for {!List.concat} *) val flatten : 'a list list -> 'a list (** Alias for {!List.flatten} *) val iter : ('a -> unit) -> 'a list -> unit (** Alias for {!List.iter} *) val map : ('a -> 'b) -> 'a list -> 'b list (** Alias for {!List.map} *) val rev_map : ('a -> 'b) -> 'a list -> 'b list (** Alias for {!List.rev_map} *) @BEGIN_FROM_5_1_0@ val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc @since 3.07.0: val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc @since 3.07.0: val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b *) val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit (** Alias for {!List.iter2} *) val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** Alias for {!List.map2} *) val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list (** Alias for {!List.rev_map2} *) @BEGIN_FROM_5_1_0@ val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a list -> 'b list -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a list -> 'b list -> 'acc @since 3.07.0: val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right2 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right2 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'acc @since 3.07.0: val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c *) val for_all : ('a -> bool) -> 'a list -> bool (** Alias for {!List.for_all} *) val exists : ('a -> bool) -> 'a list -> bool (** Alias for {!List.exists} *) val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!List.for_all2} *) val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!List.exists2} *) val mem : 'a -> 'a list -> bool (** Alias for {!List.mem} *) val memq : 'a -> 'a list -> bool (** Alias for {!List.memq} *) val find : ('a -> bool) -> 'a list -> 'a (** Alias for {!List.find} *) val filter : ('a -> bool) -> 'a list -> 'a list (** Alias for {!List.filter} *) val find_all : ('a -> bool) -> 'a list -> 'a list (** Alias for {!List.find_all} *) val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) (** Alias for {!List.partition} *) val assoc : 'a -> ('a * 'b) list -> 'b (** Alias for {!List.assoc} *) val assq : 'a -> ('a * 'b) list -> 'b (** Alias for {!List.assq} *) val mem_assoc : 'a -> ('a * 'b) list -> bool (** Alias for {!List.mem_assoc} *) val mem_assq : 'a -> ('a * 'b) list -> bool (** Alias for {!List.mem_assq} *) val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!List.remove_assoc} *) val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!List.remove_assq} *) val split : ('a * 'b) list -> ('a list * 'b list) (** Alias for {!List.split} *) val combine : 'a list -> 'b list -> ('a * 'b) list (** Alias for {!List.combine} *) val sort : ('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!List.sort} *) val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!List.stable_sort} *) val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!List.fast_sort} *) val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list (** Alias for {!List.merge} *) end ocaml-stdcompat-20~git20240529/stdcompat__map.ml.in000066400000000000000000000605641463722102200220610ustar00rootroot00000000000000module type OrderedType = Map.OrderedType module type S = sig type key @BEGIN_FROM_4_12_0@ type +!'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type +'a t @END_BEFORE_4_12_0@ val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end @BEGIN_FROM_5_1_0@ module Make = Map.Make @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Make (Ord : OrderedType) = struct include Map.Make (Ord) @BEGIN_BEFORE_4_07_0@ let add_seq g m = Stdcompat__seq.fold_left (fun m (k, v) -> add k v m) m g let of_seq g = add_seq g empty @END_BEFORE_4_07_0@ @BEGIN_WITH_MAGIC@ @BEGIN_BEFORE_4_12_0@ type 'a internal = | Empty | Node of 'a internal * key * 'a * 'a internal * int @BEGIN_FROM_4_02_0@ [@@ocaml.warning "-37"] @END_FROM_4_02_0@ @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_11_0@ external t_of_internal : 'a internal -> 'a t = "%identity" @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_12_0@ external internal_of_t : 'a t -> 'a internal = "%identity" @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_05_0@ let rec min_binding_aux l v d = match l with | Empty -> v, d | Node (l', v', d', _r, _h) -> min_binding_aux l' v' d' let min_binding_opt (map : 'a t) = match internal_of_t map with | Empty -> None | Node (l, v, d, _r, _h) -> Some (min_binding_aux l v d) let rec max_binding_aux v d r = match r with | Empty -> v, d | Node (_, v', d', r', _h) -> max_binding_aux v' d' r' let max_binding_opt (map : 'a t) = match internal_of_t map with | Empty -> None | Node (_l, v, d, r, _h) -> Some (max_binding_aux v d r) @END_BEFORE_4_05_0@ @BEGIN_BEFORE_3_12_0@ let singleton key value = t_of_internal (Node (Empty, key, value, Empty, 1)) let min_binding map = match map with | Empty -> raise Not_found | Node (l, v, d, _r, _h) -> min_binding_aux l v d let min_binding (map : 'a t) = min_binding (internal_of_t map) let max_binding map = match map with | Empty -> raise Not_found | Node (_l, v, d, r, _h) -> max_binding_aux v d r let max_binding (map : 'a t) = max_binding (internal_of_t map) @END_BEFORE_3_12_0@ @BEGIN_BEFORE_3_08_0@ let rec iter f = function | Empty -> () | Node (l, v, d, r, _) as t -> iter f l; f v d; iter f r let iter (f : key -> 'a -> unit) (s : 'a t) : unit = iter f (internal_of_t s) let rec fold f s a = match s with | Empty -> a | Node (l, v, d, r, _) as t -> let a = fold f l a in let a = f v d a in fold f r a let fold (f : key -> 'a -> 'b -> 'b) (s : 'a t) (a : 'b) : 'b = fold f (internal_of_t s) a @END_BEFORE_3_08_0@ @BEGIN_BEFORE_4_11_0@ let height map = match map with | Empty -> 0 | Node (_l, _v, _d, _r, h) -> h let create l x d r = Node (l, x, d, r, (max (height l) (height r)) + 1) let destruct map = match map with | Empty -> assert false | Node (l, v, d, r, h) -> l, v, d, r, h let bal l x d r = let hl = height l and hr = height r in if hl > hr + 2 then begin let ll, lv, ld, lr, _h = destruct l in if height ll >= height lr then create ll lv ld (create lr x d r) else let lrl, lrv, lrd, lrr, _ = destruct lr in create (create ll lv ld lrl) lrv lrd (create lrr x d r) end else if hr > hl + 2 then begin let rl, rv, rd, rr, _h = destruct r in if height rr >= height rl then create (create l x d rl) rv rd rr else let rll, rlv, rld, rlr, _h = destruct rl in create (create l x d rll) rlv rld (create rlr rv rd rr) end else Node (l, x, d, r, (max hl hr) + 1) let rec remove_min_binding map = match map with | Empty -> assert false | Node (Empty, _v, _d, r, _h) -> r | Node (l, v, d, r, _h) -> bal (remove_min_binding l) v d r let rec add_min_binding k x map = match map with | Empty -> internal_of_t (singleton k x) | Node (l, v, d, r, _h) -> bal (add_min_binding k x l) v d r let rec add_max_binding k x = function | Empty -> internal_of_t (singleton k x) | Node (l, v, d, r, _h) -> bal l v d (add_max_binding k x r) let rec join l v d r = match l, r with | Empty, _ -> add_min_binding v d r | _, Empty -> add_max_binding v d l | Node (ll, lv, ld, lr, lh), Node (rl, rv, rd, rr, rh) -> if lh > rh + 2 then bal ll lv ld (join lr v d r) else if rh > lh + 2 then bal (join l v d rl) rv rd rr else create l v d r let concat t1 t2 = match t1, t2 with | Empty, t | t, Empty -> t | _ -> let x, d = min_binding (t_of_internal t2) in join t1 x d (remove_min_binding t2) let rec filter_map f = function | Empty -> Empty | Node (l, v, d, r, _) -> let l' = filter_map f l in let fvd = f v d in let r' = filter_map f r in begin match fvd with | Some d' -> join l' v d' r' | None -> concat l' r' end let filter_map (f : key -> 'a -> 'b option) (m : 'a t) : 'b t = t_of_internal (filter_map f (internal_of_t m)) @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_12_0@ type 'a enumeration = | End | More of key * 'a * 'a internal * 'a enumeration let rec snoc_enum m e = match m with | Empty -> e | Node (l, v, d, r, _h) -> snoc_enum r (More (v, d, l, e)) let rec rev_seq_of_enum_ c () = match c with | End -> Stdcompat__seq.Nil | More (k,v,t,rest) -> Stdcompat__seq.Cons ((k,v), rev_seq_of_enum_ (snoc_enum t rest)) let to_rev_seq (m : 'a t) = rev_seq_of_enum_ (snoc_enum (internal_of_t m) End) @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_07_0@ let rec cons_enum m e = match m with Empty -> e | Node (l, v, d, r, _h) -> cons_enum l (More (v, d, r, e)) let rec seq_of_enum_ c () = match c with | End -> Stdcompat__seq.Nil | More (k,v,t,rest) -> Stdcompat__seq.Cons ((k,v), seq_of_enum_ (cons_enum t rest)) let to_seq (m : 'a t) = seq_of_enum_ (cons_enum (internal_of_t m) End) let to_seq_from low (m : 'a t) = let rec aux low m c = match m with | Empty -> c | Node (l, v, d, r, _h) -> begin match Ord.compare v low with | 0 -> More (v, d, r, c) | n when n<0 -> aux low r c | _ -> aux low l (More (v, d, r, c)) end in seq_of_enum_ (aux low (internal_of_t m) End) @END_BEFORE_4_07_0@ @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ @BEGIN_BEFORE_3_12_0@ let singleton key value = add key value empty let bindings map = fold (fun v d accu -> (v, d) :: accu) map [] @BEGIN_FROM_3_08_0@ let bindings map = List.rev (bindings map) @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ let iter f s = List.iter (fun (k, d) -> f k d) (bindings s) let fold f s a = List.fold_left (fun a (k, d) -> f k d a) a (bindings s) @END_BEFORE_3_08_0@ @END_BEFORE_3_12_0@ @BEGIN_BEFORE_4_11_0@ let filter_map f map = fold (fun x d map' -> match f x d with | Some d' -> add x d' map' | None -> map') map empty @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_12_0@ let to_rev_seq m = Stdcompat__list.to_seq (List.rev (bindings m)) @END_BEFORE_4_12_0@ @END_WITHOUT_MAGIC@ @BEGIN_WITH_MAGIC@ @BEGIN_BEFORE_4_06_0@ let simple_merge t1 t2 = match t1, t2 with | Empty, t -> t | t, Empty -> t | _ -> let x, d = min_binding (t_of_internal t2) in bal t1 x d (remove_min_binding t2) let rec update x f map = match map with | Empty -> begin match f None with | None -> Empty | Some data -> Node (Empty, x, data, Empty, 1) end | Node (l, v, d, r, h) as m -> let c = Ord.compare x v in if c = 0 then begin match f (Some d) with | None -> simple_merge l r | Some data -> if d == data then m else Node (l, x, data, r, h) end else if c < 0 then let ll = update x f l in if l == ll then m else bal ll v d r else let rr = update x f r in if r == rr then m else bal l v d rr let update x f (map : 'a t) = t_of_internal (update x f (internal_of_t map)) @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_05_0@ let rec find_opt key (map : 'a internal) = match map with | Empty -> None | Node (l, v, d, r, _h) -> let c = Ord.compare key v in if c = 0 then Some d else find_opt key (if c < 0 then l else r) let find_opt key (map : 'a t) = find_opt key (internal_of_t map) let rec find_first_aux v d p m = match m with | Empty -> (v, d) | Node (l, v', d', r, _h) -> if p v' then find_first_aux v' d' p l else find_first_aux v d p r let rec find_first_opt p m = match m with | Empty -> None | Node (l, v, d, r, _h) -> if p v then Some (find_first_aux v d p l) else find_first_opt p r let find_first_opt p (m : 'a t) = find_first_opt p (internal_of_t m) let rec find_first p m = match m with | Empty -> raise Not_found | Node (l, v, d, r, _h) -> if p v then find_first_aux v d p l else find_first p r let find_first p (m : 'a t) = find_first p (internal_of_t m) let rec find_last_aux v d p m = match m with | Empty -> (v, d) | Node (l, v', d', r, _h) -> if p v' then find_last_aux v' d' p r else find_last_aux v d p l let rec find_last_opt p m = match m with | Empty -> None | Node (l, v, d, r, _h) -> if p v then Some (find_last_aux v d p r) else find_last_opt p l let find_last_opt p (m : 'a t) = find_last_opt p (internal_of_t m) let rec find_last p m = match m with | Empty -> raise Not_found | Node (l, v, d, r, _h) -> if p v then find_last_aux v d p r else find_last p l let find_last p (m : 'a t) = find_last p (internal_of_t m) @END_BEFORE_4_05_0@ @BEGIN_BEFORE_3_12_0@ let rec split x map = match map with | Empty -> Empty, None, Empty | Node (l, v, d, r, _h) -> let c = Ord.compare x v in if c = 0 then l, Some d, r else if c < 0 then let ll, pres, rl = split x l in ll, pres, join rl v d r else let lr, pres, rr = split x r in join l v d lr, pres, rr let split x (map : 'a t) : ('a t * 'a option * 'a t) = let (l : 'a internal), item, (r : 'a internal) = split x (internal_of_t map) in (t_of_internal l, item, t_of_internal r) @END_BEFORE_3_12_0@ @BEGIN_BEFORE_4_03_0@ let concat_or_join t1 v d t2 = match d with | Some d -> join t1 v d t2 | None -> concat t1 t2 let rec union f s1 s2 = match s1, s2 with | Empty, s | s, Empty -> s | Node (l1, v1, d1, r1, h1), Node (l2, v2, d2, r2, h2) -> if h1 >= h2 then let (l2, d2, r2) = split v1 (t_of_internal s2) in let l = union f l1 (internal_of_t l2) and r = union f r1 (internal_of_t r2) in match d2 with | None -> join l v1 d1 r | Some d2 -> concat_or_join l v1 (f v1 d1 d2) r else let (l1, d1, r1) = split v2 (t_of_internal s1) in let l = union f (internal_of_t l1) l2 and r = union f (internal_of_t r1) r2 in match d1 with | None -> join l v2 d2 r | Some d1 -> concat_or_join l v2 (f v2 d1 d2) r let union f (s1 : 'a t) (s2 : 'a t) : 'a t = t_of_internal (union f (internal_of_t s1) (internal_of_t s2)) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_3_12_0@ let rec bindings_aux accu map = match map with | Empty -> accu | Node (l, v, d, r, _h) -> bindings_aux ((v, d) :: bindings_aux accu r) l let bindings (map : 'a t) = bindings_aux [] (internal_of_t map) let rec merge f s1 s2 = match s1, s2 with | Empty, Empty -> Empty | Node (l1, v1, d1, r1, h1), _ when h1 >= height s2 -> let l2, d2, r2 = split v1 (t_of_internal s2) in concat_or_join (merge f l1 (internal_of_t l2)) v1 (f v1 (Some d1) d2) (merge f r1 (internal_of_t r2)) | _, Node (l2, v2, d2, r2, _h2) -> let (l1, d1, r1) = split v2 (t_of_internal s1) in concat_or_join (merge f (internal_of_t l1) l2) v2 (f v2 d1 (Some d2)) (merge f (internal_of_t r1) r2) | _ -> assert false let merge (f : key -> 'a option -> 'b option -> 'c option) (map : 'a t) (map' : 'b t) : 'c t = let result : 'c internal = merge f (internal_of_t map) (internal_of_t map') in t_of_internal result let rec partition p map = match map with | Empty -> Empty, Empty | Node (l, v, d, r, _h) -> let (lt, lf) = partition p l in let pvd = p v d in let (rt, rf) = partition p r in if pvd then join lt v d rt, concat lf rf else concat lt rt, join lf v d rf let partition p (map : 'a t) : 'a t * 'a t = let (true_map : 'a internal), (false_map : 'a internal) = partition p (internal_of_t map) in t_of_internal true_map, t_of_internal false_map let rec filter p map = match map with | Empty -> Empty | Node (l, v, d, r, _h) as m -> let l' = filter p l in let pvd = p v d in let r' = filter p r in if pvd then if l==l' && r==r' then m else join l' v d r' else concat l' r' let filter p (map : 'a t) : 'a t = let map : 'a internal = internal_of_t map in let result : 'a internal = filter p map in t_of_internal result let rec for_all p = function | Empty -> true | Node (l, v, d, r, _h) -> p v d && for_all p l && for_all p r let for_all p (map : 'a t) = let map : 'a internal = internal_of_t map in for_all p map let rec exists p = function | Empty -> false | Node (l, v, d, r, _h) -> p v d || exists p l || exists p r let exists p (map : 'a t) = let map : 'a internal = internal_of_t map in exists p map let compare cmp m1 m2 = let rec compare_aux e1 e2 = match e1, e2 with End, End -> 0 | End, _ -> -1 | _, End -> 1 | More(v1, d1, r1, e1), More(v2, d2, r2, e2) -> let c = Ord.compare v1 v2 in if c <> 0 then c else let c = cmp d1 d2 in if c <> 0 then c else compare_aux (cons_enum r1 e1) (cons_enum r2 e2) in compare_aux (cons_enum m1 End) (cons_enum m2 End) let compare cmp (map : 'a t) (map' : 'a t) = let map : 'a internal = internal_of_t map in let map' : 'a internal = internal_of_t map' in compare cmp map map' let equal cmp m1 m2 = let rec equal_aux e1 e2 = match e1, e2 with | End, End -> true | End, _ -> false | _, End -> false | More(v1, d1, r1, e1), More(v2, d2, r2, e2) -> Ord.compare v1 v2 = 0 && cmp d1 d2 && equal_aux (cons_enum r1 e1) (cons_enum r2 e2) in equal_aux (cons_enum m1 End) (cons_enum m2 End) let equal eq (map : 'a t) (map' : 'a t) = let map : 'a internal = internal_of_t map in let map' : 'a internal = internal_of_t map' in equal eq map map' @END_BEFORE_3_12_0@ @BEGIN_BEFORE_3_08_0@ let is_empty (map : 'a t) = match (internal_of_t map : 'a internal) with | Empty -> true | Node _ -> false @END_BEFORE_3_08_0@ @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ @BEGIN_BEFORE_4_07_0@ let to_seq m = Stdcompat__list.to_seq (bindings m) let bindings_from low s = let rec cut l = match l with | [] -> [] | (key, _) :: tl -> if Ord.compare low key < 0 then cut tl else l in cut (bindings s) let to_seq_from low s = Stdcompat__list.to_seq (bindings_from low s) @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ exception Local_exit let find_opt key m = Stdcompat__tools.option_find (find key) m let find_first_opt p m = let result = ref None in iter (fun v d -> if p v then begin result := Some (v, d); raise Local_exit end) m; !result let find_first p m = match find_first_opt p m with | None -> raise Not_found | Some (v, d) -> v, d let find_last_opt p m = let result = ref None in iter (fun v d -> if p v then result := Some (v, d)) m; !result let find_last p m = match find_last_opt p m with | None -> raise Not_found | Some (v, d) -> v, d @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_06_0@ let update x f map = let d = find_opt x map in let d' = f d in match d, d' with | None, None -> map | Some _, None -> remove x map | Some d, Some d' when d == d' -> map | _, Some d' -> add x d' map @END_BEFORE_4_06_0@ @BEGIN_BEFORE_3_12_0@ let accu_binding v d accu = match d with | None -> accu | Some d -> add v d accu let rec add_left_bindings f b accu = List.fold_left (fun accu (v, d) -> accu_binding v (f v (Some d) None) accu) accu b let rec add_right_bindings f b accu = List.fold_left (fun accu (v, d) -> accu_binding v (f v None (Some d)) accu) accu b let merge f map map' = let b = bindings map and b' = bindings map' in let rec merge_bindings b b' accu = match b, b' with | [], _ -> add_right_bindings f b' accu | _, [] -> add_left_bindings f b accu | (v, d) :: tl, (v', d') :: tl' -> let c = Ord.compare v v' in if c < 0 then merge_bindings tl b' (accu_binding v (f v (Some d) None) accu) else if c > 0 then merge_bindings b tl' (accu_binding v' (f v' None (Some d')) accu) else merge_bindings tl tl' (accu_binding v (f v (Some d) (Some d')) accu) in merge_bindings b b' empty @END_BEFORE_3_12_0@ @BEGIN_BEFORE_4_03_0@ let union f map map' = let f' key v v' = match v, v' with | None, None -> None | Some v, None | None, Some v -> Some v | Some v, Some v' -> f key v v' in merge f' map map' @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ @BEGIN_FROM_3_12_0@ let min_binding_opt m = Stdcompat__tools.option_find min_binding m let max_binding_opt m = Stdcompat__tools.option_find max_binding m @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ let min_binding_opt m = let binding = ref None in try iter (fun v d -> binding := Some ((v, d)); raise Local_exit) m; None with Local_exit -> !binding let min_binding m = match min_binding_opt m with | None -> raise Not_found | Some result -> result let max_binding_opt m = let binding = ref None in iter (fun v d -> binding := Some (v, d)) m; !binding let max_binding m = match max_binding_opt m with | None -> raise Not_found | Some result -> result let partition p map = fold (fun x d (true_map, false_map) -> if p x d then add x d true_map, false_map else true_map, add x d false_map) map (empty, empty) let split x t = fold (fun key value (ll, pres, rl) -> let c = Ord.compare key x in if c < 0 then (add key value ll, pres, rl) else if c > 0 then (ll, pres, add key value rl) else (ll, Some value, rl)) t (empty, None, empty) let filter p map = fold (fun x d map' -> if p x d then add x d map' else map') map empty let exists p map = try iter (fun key value -> if p key value then raise Local_exit) map; false with Local_exit -> true let for_all p map = try iter (fun key value -> if not (p key value) then raise Local_exit) map; true with Local_exit -> false @END_BEFORE_3_12_0@ @END_BEFORE_4_05_0@ @BEGIN_BEFORE_3_08_0@ let is_empty map = for_all (fun _ _ -> false) map exception Compare_return of int let compare cmp map map' = try let seq' = fold (fun key value seq' -> match seq' () with | Stdcompat__seq.Nil -> raise (Compare_return 1) | Stdcompat__seq.Cons ((key', value'), tail) -> match Ord.compare key key' with | 0 -> begin match cmp value value' with | 0 -> tail | diff -> raise (Compare_return diff) end | diff -> raise (Compare_return diff)) map (to_seq map') in match seq' () with | Stdcompat__seq.Nil -> 0 | Stdcompat__seq.Cons _ -> -1 with Compare_return result -> result let equal eq map map' = try let seq' = fold (fun key value seq' -> match seq' () with | Stdcompat__seq.Nil -> raise Local_exit | Stdcompat__seq.Cons ((key', value'), tail) -> match Ord.compare key key' with | 0 -> begin if eq value value' then tail else raise Local_exit end | diff -> raise Local_exit) map (to_seq map') in match seq' () with | Stdcompat__seq.Nil -> true | Stdcompat__seq.Cons _ -> false with Local_exit -> false @END_BEFORE_3_08_0@ @END_WITHOUT_MAGIC@ @BEGIN_BEFORE_4_05_0@ let choose_opt = min_binding_opt @END_BEFORE_4_05_0@ @BEGIN_BEFORE_3_12_0@ let choose = min_binding let cardinal map = fold (fun _ _ counter -> succ counter) map 0 @END_BEFORE_3_12_0@ @BEGIN_BEFORE_5_1_0@ let add_to_list key data m = update key (fun opt -> match opt with None -> Some [data] | Some list -> Some (data :: list)) m let to_list m = bindings m let of_list l = List.fold_left (fun acc (key, value) -> add key value acc) empty l @END_BEFORE_5_1_0@ end @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__map.mli.in000066400000000000000000000000331463722102200222130ustar00rootroot00000000000000include Stdcompat__map_s.S ocaml-stdcompat-20~git20240529/stdcompat__map_s.mli.in000066400000000000000000000217251463722102200225500ustar00rootroot00000000000000module type S = sig module type OrderedType = sig type t val compare : t -> t -> int end (** Alias for {!Map.OrderedType} *) @BEGIN_FROM_5_1_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type +!'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type +'a t @END_BEFORE_4_12_0@ val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module type S = sig type key @BEGIN_FROM_4_12_0@ type +!'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type +'a t @END_BEFORE_4_12_0@ val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_rev_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_from : key -> 'a t -> (key * 'a) Stdcompat__seq.t val add_seq : (key * 'a) Stdcompat__seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @END_BEFORE_5_1_0@ (** @since 5.1.0: module type S = sig type key type +!'a t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Seq.t val to_rev_seq : 'a t -> (key * 'a) Seq.t val to_seq_from : key -> 'a t -> (key * 'a) Seq.t val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Seq.t -> 'a t end *) @BEGIN_FROM_5_1_0@ module Make = Map.Make @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type +'a t = 'a Map.Make(Ord).t val empty : 'a t val add : key -> 'a -> 'a t -> 'a t val add_to_list : key -> 'a -> 'a list t -> 'a list t 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 -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : (key -> bool) -> 'a t -> (key * 'a) val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option val find_last : (key -> bool) -> 'a t -> (key * 'a) val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option val iter : (key -> 'a -> unit) -> 'a t -> unit 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 -> bool) -> 'a t -> 'a t val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t val partition : (key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : (key -> 'a -> bool) -> 'a t -> bool val exists : (key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_rev_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_from : key -> 'a t -> (key * 'a) Stdcompat__seq.t val add_seq : (key * 'a) Stdcompat__seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end @END_BEFORE_5_1_0@ (** @since 5.1.0: module Make = Map.Make *) end ocaml-stdcompat-20~git20240529/stdcompat__moreLabels.ml.in000066400000000000000000000006361463722102200233630ustar00rootroot00000000000000@BEGIN_FROM_5_1_0@ module Hashtbl = MoreLabels.Hashtbl @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Hashtbl = Stdcompat__hashtbl @END_BEFORE_5_1_0@ @BEGIN_FROM_5_1_0@ module Map = MoreLabels.Map @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Map = Stdcompat__map @END_BEFORE_5_1_0@ @BEGIN_FROM_5_1_0@ module Set = MoreLabels.Set @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Set = Stdcompat__set @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__moreLabels.mli.in000066400000000000000000000000421463722102200235230ustar00rootroot00000000000000include Stdcompat__moreLabels_s.S ocaml-stdcompat-20~git20240529/stdcompat__moreLabels_s.mli.in000066400000000000000000000340361463722102200240570ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_5_0_0@ module Hashtbl = MoreLabels.Hashtbl @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module Hashtbl : sig type ('a, 'b) t = ('a, 'b) Hashtbl.t val create : ?random:bool -> int -> ('a, 'b) t val clear : ('a, 'b) t -> unit val reset : ('a, 'b) t -> unit val copy : ('a, 'b) t -> ('a, 'b) t val add : ('a, 'b) t -> key:'a -> data:'b -> unit val find : ('a, 'b) t -> 'a -> 'b val find_opt : ('a, 'b) t -> 'a -> 'b option val find_all : ('a, 'b) t -> 'a -> 'b list val mem : ('a, 'b) t -> 'a -> bool val remove : ('a, 'b) t -> 'a -> unit val replace : ('a, 'b) t -> key:'a -> data:'b -> unit val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit val filter_map_inplace : f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit val fold : f:(key:'a -> data:'b -> 'acc -> 'acc) -> ('a, 'b) t -> init:'acc -> 'acc val length : ('a, 'b) t -> int val randomize : unit -> unit val is_randomized : unit -> bool val rebuild : ?random:bool -> ('a, 'b) t -> ('a, 'b) t type statistics = Stdcompat__hashtbl_ext.statistics = { num_bindings: int ; num_buckets: int ; max_bucket_length: int ; bucket_histogram: int array } val stats : ('a, 'b) t -> statistics val to_seq : ('a, 'b) t -> ('a * 'b) Stdcompat__seq.t val to_seq_keys : ('a, 'b) t -> 'a Stdcompat__seq.t val to_seq_values : ('a, 'b) t -> 'b Stdcompat__seq.t val add_seq : ('a, 'b) t -> ('a * 'b) Stdcompat__seq.t -> unit val replace_seq : ('a, 'b) t -> ('a * 'b) Stdcompat__seq.t -> unit val of_seq : ('a * 'b) Stdcompat__seq.t -> ('a, 'b) t module type HashedType = sig type t val equal : t -> t -> bool val hash : t -> int end module type S = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end module Make : functor (H : HashedType) -> sig type key = H.t type 'a t = 'a Hashtbl.Make(H).t val create : int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end module type SeededHashedType = sig type t val equal : t -> t -> bool val seeded_hash : int -> t -> int end module type SeededS = sig type key @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end module MakeSeeded : functor (H : SeededHashedType) -> sig type key = H.t type 'a t = 'a Stdcompat__hashtbl_ext.MakeSeeded(H).t val create : ?random:bool -> int -> 'a t val clear : 'a t -> unit val reset : 'a t -> unit val copy : 'a t -> 'a t val add : 'a t -> key:key -> data:'a -> unit val remove : 'a t -> key -> unit val find : 'a t -> key -> 'a val find_opt : 'a t -> key -> 'a option val find_all : 'a t -> key -> 'a list val replace : 'a t -> key:key -> data:'a -> unit val mem : 'a t -> key -> bool val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val filter_map_inplace : f:(key:key -> data:'a -> 'a option) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val length : 'a t -> int val stats : 'a t -> statistics val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_keys : 'a t -> key Stdcompat__seq.t val to_seq_values : 'a t -> 'a Stdcompat__seq.t val add_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val replace_seq : 'a t -> (key * 'a) Stdcompat__seq.t -> unit val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int val seeded_hash_param : int -> int -> int -> 'a -> int end @END_BEFORE_5_0_0@ (** @since 5.0.0: module Hashtbl = MoreLabels.Hashtbl *) @BEGIN_FROM_5_1_0@ module Map = MoreLabels.Map @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Map : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type key @BEGIN_FROM_4_12_0@ type +!'a t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type +'a t @END_BEFORE_4_12_0@ val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val add_to_list : key:key -> data:'a -> 'a list t -> 'a list t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_rev_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_from : key -> 'a t -> (key * 'a) Stdcompat__seq.t val add_seq : (key * 'a) Stdcompat__seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end module Make : functor (Ord : OrderedType) -> sig type key = Ord.t type 'a t = 'a Map.Make(Ord).t val empty : 'a t val add : key:key -> data:'a -> 'a t -> 'a t val add_to_list : key:key -> data:'a -> 'a list t -> 'a list t val update : key:key -> f:('a option -> 'a option) -> 'a t -> 'a t val singleton : key -> 'a -> 'a t val remove : key -> 'a t -> 'a t val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t val cardinal : 'a t -> int val bindings : 'a t -> (key * 'a) list val min_binding : 'a t -> (key * 'a) val min_binding_opt : 'a t -> (key * 'a) option val max_binding : 'a t -> (key * 'a) val max_binding_opt : 'a t -> (key * 'a) option val choose : 'a t -> (key * 'a) val choose_opt : 'a t -> (key * 'a) option val find : key -> 'a t -> 'a val find_opt : key -> 'a t -> 'a option val find_first : f:(key -> bool) -> 'a t -> (key * 'a) val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val find_last : f:(key -> bool) -> 'a t -> (key * 'a) val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit val fold : f:(key:key -> data:'a -> 'acc -> 'acc) -> 'a t -> init:'acc -> 'acc val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t val filter_map : f:(key -> 'a -> 'b option) -> 'a t -> 'b t val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t) val split : key -> 'a t -> ('a t * 'a option * 'a t) val is_empty : 'a t -> bool val mem : key -> 'a t -> bool val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int val for_all : f:(key -> 'a -> bool) -> 'a t -> bool val exists : f:(key -> 'a -> bool) -> 'a t -> bool val to_list : 'a t -> (key * 'a) list val of_list : (key * 'a) list -> 'a t val to_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_rev_seq : 'a t -> (key * 'a) Stdcompat__seq.t val to_seq_from : key -> 'a t -> (key * 'a) Stdcompat__seq.t val add_seq : (key * 'a) Stdcompat__seq.t -> 'a t -> 'a t val of_seq : (key * 'a) Stdcompat__seq.t -> 'a t end end @END_BEFORE_5_1_0@ (** @since 5.1.0: module Map = MoreLabels.Map *) @BEGIN_FROM_5_1_0@ module Set = MoreLabels.Set @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Set : sig module type OrderedType = sig type t val compare : t -> t -> int end module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val map : f:(elt -> elt) -> t -> t val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Stdcompat__seq.t val to_seq : t -> elt Stdcompat__seq.t val to_rev_seq : t -> elt Stdcompat__seq.t val add_seq : elt Stdcompat__seq.t -> t -> t val of_seq : elt Stdcompat__seq.t -> t end module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : f:(elt -> bool) -> t -> elt val find_first_opt : f:(elt -> bool) -> t -> elt option val find_last : f:(elt -> bool) -> t -> elt val find_last_opt : f:(elt -> bool) -> t -> elt option val iter : f:(elt -> unit) -> t -> unit val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc val map : f:(elt -> elt) -> t -> t val filter : f:(elt -> bool) -> t -> t val filter_map : f:(elt -> elt option) -> t -> t val partition : f:(elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : f:(elt -> bool) -> t -> bool val exists : f:(elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Stdcompat__seq.t val to_seq : t -> elt Stdcompat__seq.t val to_rev_seq : t -> elt Stdcompat__seq.t val add_seq : elt Stdcompat__seq.t -> t -> t val of_seq : elt Stdcompat__seq.t -> t end end @END_BEFORE_5_1_0@ (** @since 5.1.0: module Set = MoreLabels.Set *) end ocaml-stdcompat-20~git20240529/stdcompat__native.ml_byte.in000066400000000000000000000000221463722102200235740ustar00rootroot00000000000000let native = falseocaml-stdcompat-20~git20240529/stdcompat__native.ml_native.in000066400000000000000000000000211463722102200241160ustar00rootroot00000000000000let native = trueocaml-stdcompat-20~git20240529/stdcompat__native.mli000066400000000000000000000000221463722102200223150ustar00rootroot00000000000000val native : bool ocaml-stdcompat-20~git20240529/stdcompat__nativeint.ml.in000066400000000000000000000022731463722102200232760ustar00rootroot00000000000000include Nativeint @BEGIN_BEFORE_4_13_0@ let min i j = if compare i j >= 0 then j else i let max i j = if compare i j >= 0 then i else j @END_BEFORE_4_13_0@ @BEGIN_BEFORE_4_08_0@ let unsigned_compare i j = compare (sub i min_int) (sub j min_int) let unsigned_to_int = let max_int = of_int Stdcompat__pervasives.max_int in fun i -> if compare zero i <= 0 && compare i max_int <= 0 then Some (to_int i) else None (* Unsigned division from signed division of the same bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3. *) let unsigned_div n d = if d < zero then if unsigned_compare n d < 0 then zero else one else let q = shift_left (div (shift_right_logical n 1) d) 1 in let r = sub n (mul q d) in if unsigned_compare r d >= 0 then succ q else q let unsigned_rem n d = sub n (mul (unsigned_div n d) d) @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_03_0@ let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ let of_string_opt s = Stdcompat__tools.option_fail of_string s @END_BEFORE_4_05_0@ @BEGIN_BEFORE_5_1_0@ let hash = Hashtbl.hash let seeded_hash = Stdcompat__hashtbl.seeded_hash @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__nativeint.mli.in000066400000000000000000000000411463722102200234360ustar00rootroot00000000000000include Stdcompat__nativeint_s.S ocaml-stdcompat-20~git20240529/stdcompat__nativeint_s.mli.in000066400000000000000000000124371463722102200237740ustar00rootroot00000000000000module type S = sig type t = nativeint (** Alias for {!Nativeint.t} *) val seeded_hash : int -> t -> int (** @since 5.1.0: val seeded_hash : int -> t -> int *) val hash : t -> int (** @since 5.1.0: val hash : t -> int *) val min : t -> t -> t (** @since 4.13.0: val min : t -> t -> t *) val max : t -> t -> t (** @since 4.13.0: val max : t -> t -> t *) val unsigned_div : nativeint -> nativeint -> nativeint (** @since 4.08.0: val unsigned_div : nativeint -> nativeint -> nativeint *) val unsigned_rem : nativeint -> nativeint -> nativeint (** @since 4.08.0: val unsigned_rem : nativeint -> nativeint -> nativeint *) val unsigned_to_int : nativeint -> int option (** @since 4.08.0: val unsigned_to_int : nativeint -> int option *) val unsigned_compare : t -> t -> int (** @since 4.08.0: val unsigned_compare : t -> t -> int *) val of_string_opt : string -> nativeint option (** @since 4.05.0: val of_string_opt : string -> nativeint option *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) val zero : nativeint (** Alias for {!Nativeint.zero} *) val one : nativeint (** Alias for {!Nativeint.one} *) val minus_one : nativeint (** Alias for {!Nativeint.minus_one} *) external neg : nativeint -> nativeint = "%nativeint_neg" (** Alias for {!Nativeint.neg} *) external add : nativeint -> nativeint -> nativeint = "%nativeint_add" (** Alias for {!Nativeint.add} *) external sub : nativeint -> nativeint -> nativeint = "%nativeint_sub" (** Alias for {!Nativeint.sub} *) external mul : nativeint -> nativeint -> nativeint = "%nativeint_mul" (** Alias for {!Nativeint.mul} *) external div : nativeint -> nativeint -> nativeint = "%nativeint_div" (** Alias for {!Nativeint.div} *) external rem : nativeint -> nativeint -> nativeint = "%nativeint_mod" (** Alias for {!Nativeint.rem} *) val succ : nativeint -> nativeint (** Alias for {!Nativeint.succ} *) val pred : nativeint -> nativeint (** Alias for {!Nativeint.pred} *) val abs : nativeint -> nativeint (** Alias for {!Nativeint.abs} *) val size : int (** Alias for {!Nativeint.size} *) val max_int : nativeint (** Alias for {!Nativeint.max_int} *) val min_int : nativeint (** Alias for {!Nativeint.min_int} *) external logand : nativeint -> nativeint -> nativeint = "%nativeint_and" (** Alias for {!Nativeint.logand} *) external logor : nativeint -> nativeint -> nativeint = "%nativeint_or" (** Alias for {!Nativeint.logor} *) external logxor : nativeint -> nativeint -> nativeint = "%nativeint_xor" (** Alias for {!Nativeint.logxor} *) val lognot : nativeint -> nativeint (** Alias for {!Nativeint.lognot} *) external shift_left : nativeint -> int -> nativeint = "%nativeint_lsl" (** Alias for {!Nativeint.shift_left} *) external shift_right : nativeint -> int -> nativeint = "%nativeint_asr" (** Alias for {!Nativeint.shift_right} *) external shift_right_logical : nativeint -> int -> nativeint = "%nativeint_lsr" (** Alias for {!Nativeint.shift_right_logical} *) external of_int : int -> nativeint = "%nativeint_of_int" (** Alias for {!Nativeint.of_int} *) external to_int : nativeint -> int = "%nativeint_to_int" (** Alias for {!Nativeint.to_int} *) @BEGIN_FROM_4_03_0@ external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external of_float : float -> nativeint = "caml_nativeint_of_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_float : float -> nativeint = "nativeint_of_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external of_float : float -> nativeint = "caml_nativeint_of_float" "caml_nativeint_of_float_unboxed"[@@unboxed ][@@noalloc ] @since 3.08.0: external of_float : float -> nativeint = "caml_nativeint_of_float" @since 3.07.0: external of_float : float -> nativeint = "nativeint_of_float" *) @BEGIN_FROM_4_03_0@ external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external to_float : nativeint -> float = "caml_nativeint_to_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external to_float : nativeint -> float = "nativeint_to_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external to_float : nativeint -> float = "caml_nativeint_to_float" "caml_nativeint_to_float_unboxed"[@@unboxed ][@@noalloc ] @since 3.08.0: external to_float : nativeint -> float = "caml_nativeint_to_float" @since 3.07.0: external to_float : nativeint -> float = "nativeint_to_float" *) external of_int32 : int32 -> nativeint = "%nativeint_of_int32" (** Alias for {!Nativeint.of_int32} *) external to_int32 : nativeint -> int32 = "%nativeint_to_int32" (** Alias for {!Nativeint.to_int32} *) @BEGIN_FROM_3_08_0@ external of_string : string -> nativeint = "caml_nativeint_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external of_string : string -> nativeint = "nativeint_of_string" @END_BEFORE_3_08_0@ (** @since 3.08.0: external of_string : string -> nativeint = "caml_nativeint_of_string" @since 3.07.0: external of_string : string -> nativeint = "nativeint_of_string" *) val to_string : nativeint -> string (** Alias for {!Nativeint.to_string} *) val compare : t -> t -> int (** Alias for {!Nativeint.compare} *) end ocaml-stdcompat-20~git20240529/stdcompat__option.ml.in000066400000000000000000000024711463722102200226050ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Option @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a option = | None | Some of 'a let none = None let some x = Some x let value o ~default = match o with | None -> default | Some v -> v let get o = match o with | None -> invalid_arg "option is None" | Some v -> v let bind o f = match o with | None -> None | Some v -> f v let join o = match o with | None -> None | Some v -> v let map f o = match o with | None -> None | Some v -> Some (f v) let fold ~none ~some o = match o with | None -> none | Some v -> some v let iter f o = match o with | None -> () | Some v -> f v let is_none o = o = None let is_some o = o <> None let equal eq o o' = match o, o' with | None, None -> true | Some v, Some v' -> eq v v' | None, Some _ | Some _, None -> false let compare cmp o o' = match o, o' with | None, None -> 0 | None, Some _ -> -1 | Some _, None -> 1 | Some v, Some v' -> cmp v v' let to_result ~none o = match o with | None -> Stdcompat__pervasives.Error none | Some v -> Stdcompat__pervasives.Ok v let to_list o = match o with | None -> [] | Some v -> [v] let to_seq o = match o with | Some v -> fun () -> Stdcompat__seq.Cons (v, Stdcompat__seq.empty) | None -> Stdcompat__seq.empty @END_BEFORE_4_08_0@ ocaml-stdcompat-20~git20240529/stdcompat__option.mli.in000066400000000000000000000000361463722102200227510ustar00rootroot00000000000000include Stdcompat__option_s.S ocaml-stdcompat-20~git20240529/stdcompat__option_s.mli.in000066400000000000000000000044441463722102200233020ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type 'a t = 'a option = | None | Some of 'a @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a option = | None | Some of 'a @END_BEFORE_4_08_0@ (** @since 4.08.0: type 'a t = 'a option = | None | Some of 'a *) val none : 'a option (** @since 4.08.0: val none : 'a option *) val some : 'a -> 'a option (** @since 4.08.0: val some : 'a -> 'a option *) val value : 'a option -> default:'a -> 'a (** @since 4.08.0: val value : 'a option -> default:'a -> 'a *) val get : 'a option -> 'a (** @since 4.08.0: val get : 'a option -> 'a *) val bind : 'a option -> ('a -> 'b option) -> 'b option (** @since 4.08.0: val bind : 'a option -> ('a -> 'b option) -> 'b option *) val join : 'a option option -> 'a option (** @since 4.08.0: val join : 'a option option -> 'a option *) val map : ('a -> 'b) -> 'a option -> 'b option (** @since 4.08.0: val map : ('a -> 'b) -> 'a option -> 'b option *) val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a (** @since 4.08.0: val fold : none:'a -> some:('b -> 'a) -> 'b option -> 'a *) val iter : ('a -> unit) -> 'a option -> unit (** @since 4.08.0: val iter : ('a -> unit) -> 'a option -> unit *) val is_none : 'a option -> bool (** @since 4.08.0: val is_none : 'a option -> bool *) val is_some : 'a option -> bool (** @since 4.08.0: val is_some : 'a option -> bool *) val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool (** @since 4.08.0: val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool *) val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int (** @since 4.08.0: val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int *) @BEGIN_FROM_4_08_0@ val to_result : none:'e -> 'a option -> ('a, 'e) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val to_result : none:'e -> 'a option -> ('a, 'e) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val to_result : none:'e -> 'a option -> ('a, 'e) result *) val to_list : 'a option -> 'a list (** @since 4.08.0: val to_list : 'a option -> 'a list *) @BEGIN_FROM_4_08_0@ val to_seq : 'a option -> 'a Seq.t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val to_seq : 'a option -> 'a Stdcompat__seq.t @END_BEFORE_4_08_0@ (** @since 4.08.0: val to_seq : 'a option -> 'a Seq.t *) end ocaml-stdcompat-20~git20240529/stdcompat__out_channel.ml.in000066400000000000000000000033171463722102200235740ustar00rootroot00000000000000@BEGIN_FROM_4_14_0@ include Out_channel @END_FROM_4_14_0@ @BEGIN_BEFORE_5_2_0@ let output_bigarray _channel _src _pos _len = failwith "output_bigarray" let is_binary_mode _channel = failwith "is_binary_mode" @END_BEFORE_5_2_0@ @BEGIN_BEFORE_4_14_0@ type t = out_channel type open_flag = Pervasives.open_flag = Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock let stdout = stdout let stderr = stderr let open_bin = open_out_bin let open_text = open_out let open_gen = open_out_gen let read_and_close channel f = Stdcompat__fun.protect ~finally:(fun () -> close_out_noerr channel) (fun () -> f channel) let with_open_bin filename f = read_and_close (open_bin filename) f let with_open_text filename f = read_and_close (open_text filename) f let with_open_gen flags perm filename f = read_and_close (open_gen flags perm filename) f let seek = LargeFile.seek_out let pos = LargeFile.pos_out let length = LargeFile.out_channel_length let close = close_out let close_noerr = close_out_noerr let flush = flush let flush_all = flush_all let output_char = output_char let output_byte = output_byte let output_string = output_string let output_bytes = Stdcompat__pervasives.output_bytes let output = output let output_substring = Stdcompat__pervasives.output_substring let set_binary_mode = set_binary_mode_out let set_buffered _ _ = failwith "Stdcompat.Out_channel.set_buffered is not implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." let is_buffered _ = true @END_BEFORE_4_14_0@ @BEGIN_BEFORE_5_1_0@ let isatty _ic = failwith "not implemented" @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__out_channel.mli.in000066400000000000000000000000431463722102200237360ustar00rootroot00000000000000include Stdcompat__out_channel_s.S ocaml-stdcompat-20~git20240529/stdcompat__out_channel_s.mli.in000066400000000000000000000073731463722102200242750ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_14_0@ type t = out_channel @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type t = out_channel @END_BEFORE_4_14_0@ (** @since 4.14.0: type t = out_channel *) @BEGIN_FROM_4_14_0@ type open_flag = Out_channel.open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock @END_BEFORE_4_14_0@ (** @since 4.14.0: type open_flag = Out_channel.open_flag = | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock *) val output_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> unit (** @since 5.2.0: val output_bigarray : t -> ('a, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t -> int -> int -> unit *) val is_binary_mode : t -> bool (** @since 5.2.0: val is_binary_mode : t -> bool *) val isatty : t -> bool (** @since 5.1.0: val isatty : t -> bool *) val stdout : t (** @since 4.14.0: val stdout : t *) val stderr : t (** @since 4.14.0: val stderr : t *) val open_bin : string -> t (** @since 4.14.0: val open_bin : string -> t *) val open_text : string -> t (** @since 4.14.0: val open_text : string -> t *) val open_gen : open_flag list -> int -> string -> t (** @since 4.14.0: val open_gen : open_flag list -> int -> string -> t *) val with_open_bin : string -> (t -> 'a) -> 'a (** @since 4.14.0: val with_open_bin : string -> (t -> 'a) -> 'a *) val with_open_text : string -> (t -> 'a) -> 'a (** @since 4.14.0: val with_open_text : string -> (t -> 'a) -> 'a *) val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a (** @since 4.14.0: val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a *) val close : t -> unit (** @since 4.14.0: val close : t -> unit *) val close_noerr : t -> unit (** @since 4.14.0: val close_noerr : t -> unit *) val output_char : t -> char -> unit (** @since 4.14.0: val output_char : t -> char -> unit *) val output_byte : t -> int -> unit (** @since 4.14.0: val output_byte : t -> int -> unit *) val output_string : t -> string -> unit (** @since 4.14.0: val output_string : t -> string -> unit *) @BEGIN_FROM_4_14_0@ val output_bytes : t -> bytes -> unit @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val output_bytes : t -> Stdcompat__init.bytes -> unit @END_BEFORE_4_14_0@ (** @since 4.14.0: val output_bytes : t -> bytes -> unit *) @BEGIN_FROM_4_14_0@ val output : t -> bytes -> int -> int -> unit @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val output : t -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_14_0@ (** @since 4.14.0: val output : t -> bytes -> int -> int -> unit *) val output_substring : t -> string -> int -> int -> unit (** @since 4.14.0: val output_substring : t -> string -> int -> int -> unit *) val flush : t -> unit (** @since 4.14.0: val flush : t -> unit *) val flush_all : unit -> unit (** @since 4.14.0: val flush_all : unit -> unit *) val seek : t -> int64 -> unit (** @since 4.14.0: val seek : t -> int64 -> unit *) val pos : t -> int64 (** @since 4.14.0: val pos : t -> int64 *) val length : t -> int64 (** @since 4.14.0: val length : t -> int64 *) val set_binary_mode : t -> bool -> unit (** @since 4.14.0: val set_binary_mode : t -> bool -> unit *) val set_buffered : t -> bool -> unit (** @since 4.14.0: val set_buffered : t -> bool -> unit *) val is_buffered : t -> bool (** @since 4.14.0: val is_buffered : t -> bool *) end ocaml-stdcompat-20~git20240529/stdcompat__pervasives.ml.in000066400000000000000000000041271463722102200234640ustar00rootroot00000000000000@BEGIN_FROM_4_07_0@ include Stdlib @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ include Pervasives @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_03_0@ type ('a, 'b) result = ('a, 'b) Stdcompat__init.result = Ok of 'a | Error of 'b @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_02_0@ external raise_notrace : exn -> 'a = "%raise" @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_05_0@ let bool_of_string_opt s = Stdcompat__tools.option_invalid bool_of_string s let int_of_string_opt s = Stdcompat__tools.option_fail int_of_string s let float_of_string_opt s = Stdcompat__tools.option_fail float_of_string s let read_int_opt () = Stdcompat__tools.option_fail read_int () let read_float_opt () = Stdcompat__tools.option_fail read_float () @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_02_0@ let print_bytes = print_string let prerr_bytes = prerr_string let output_bytes = output_string let output_substring = output let really_input_string channel len = let s = String.create len in really_input channel s 0 len; s type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdcompat__init.format6 @BEGIN_BEFORE_3_10_0@ type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 @END_BEFORE_3_10_0@ let __LOC__ = "" let __MODULE__ = "" let __POS__ = ("", 0, 0, 0) let __LOC_OF__ x = (__LOC__, x) let __LINE__ = 0 let __FILE__ = "" let __LINE_OF__ x = (0, x) let __POS_OF__ x = (__POS__, x) @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_01_0@ let ( |> ) x f = f x let ( @@ ) f x = f x @END_BEFORE_4_01_0@ @BEGIN_BEFORE_4_00_0@ let hypot x y = sqrt (x *. x +. y *. y) let copysign x y = if (x >= 0.) = (y >= 0.) then x else -. x @END_BEFORE_4_00_0@ @BEGIN_BEFORE_3_12_0@ external (~+) : int -> int = "%identity" external (~+.) : float -> float = "%identity" (* These emulations of expm1() and log1p() are due to William Kahan. See http://www.plunk.org/~hatch/rightway.php *) let expm1 x = let u = exp x in if u = 1. then x else if u -. 1. = -1. then -1. else (u -. 1.) *. x /. log u let log1p x = let u = 1. +. x in if u = 1. then x else log u *. x /. (u -. 1.) @END_BEFORE_3_12_0@ ocaml-stdcompat-20~git20240529/stdcompat__pervasives.mli.in000066400000000000000000000000421463722102200236250ustar00rootroot00000000000000include Stdcompat__pervasives_s.S ocaml-stdcompat-20~git20240529/stdcompat__pervasives_s.mli.in000066400000000000000000001034131463722102200241550ustar00rootroot00000000000000module type S = sig exception Exit type fpclass = @BEGIN_FROM_4_07_0@ Stdlib.fpclass = @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ Pervasives.fpclass = @END_BEFORE_4_07_0@ | FP_normal | FP_subnormal | FP_zero | FP_infinite | FP_nan type in_channel = Stdcompat__init.in_channel type out_channel = Stdcompat__init.out_channel type open_flag = @BEGIN_FROM_4_07_0@ Stdlib.open_flag = @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ Pervasives.open_flag = @END_BEFORE_4_07_0@ | Open_rdonly | Open_wronly | Open_append | Open_creat | Open_trunc | Open_excl | Open_binary | Open_text | Open_nonblock @BEGIN_FROM_4_02_0@ module LargeFile = @BEGIN_FROM_4_07_0@ Stdlib.LargeFile @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ Pervasives.LargeFile @END_BEFORE_4_07_0@ @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ module LargeFile : sig val seek_out : out_channel -> int64 -> unit val pos_out : out_channel -> int64 val out_channel_length : out_channel -> int64 val seek_in : in_channel -> int64 -> unit val pos_in : in_channel -> int64 val in_channel_length : in_channel -> int64 end @END_BEFORE_4_02_0@ type 'a ref = @BEGIN_FROM_4_07_0@ 'a Stdlib.ref = @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 'a Pervasives.ref = @END_BEFORE_4_07_0@ { mutable contents: 'a } type ('a, 'b) result = ('a, 'b) Stdcompat__init.result = | Ok of 'a | Error of 'b type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdcompat__init.format6 type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4 val stdin : in_channel val stdout : out_channel val stderr : out_channel val open_out : string -> out_channel val open_out_bin : string -> out_channel val open_out_gen : open_flag list -> int -> string -> out_channel val flush : out_channel -> unit val output_char : out_channel -> char -> unit val output_string : out_channel -> string -> unit val output_bytes : out_channel -> Stdcompat__init.bytes -> unit val output : out_channel -> Stdcompat__init.bytes -> int -> int -> unit val output_substring : out_channel -> string -> int -> int -> unit val output_byte : out_channel -> int -> unit val output_binary_int : out_channel -> int -> unit val output_value : out_channel -> 'a -> unit val seek_out : out_channel -> int -> unit val pos_out : out_channel -> int val out_channel_length : out_channel -> int val close_out : out_channel -> unit val close_out_noerr : out_channel -> unit val set_binary_mode_out : out_channel -> bool -> unit val open_in : string -> in_channel val open_in_bin : string -> in_channel val open_in_gen : open_flag list -> int -> string -> in_channel val input_char : in_channel -> char val input_line : in_channel -> string val input : in_channel -> Stdcompat__init.bytes -> int -> int -> int val really_input : in_channel -> Stdcompat__init.bytes -> int -> int -> unit val really_input_string : in_channel -> int -> string val input_byte : in_channel -> int val input_binary_int : in_channel -> int val input_value : in_channel -> 'a val seek_in : in_channel -> int -> unit val pos_in : in_channel -> int val in_channel_length : in_channel -> int val close_in : in_channel -> unit val close_in_noerr : in_channel -> unit val set_binary_mode_in : in_channel -> bool -> unit val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6 val bool_of_string_opt : string -> bool option val int_of_string_opt : string -> int option val float_of_string_opt : string -> float option val read_int_opt : unit -> int option val read_float_opt : unit -> float option @BEGIN_FROM_4_02_0@ external raise_notrace : exn -> 'a = "%raise_notrace" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external raise_notrace : exn -> 'a = "%raise" @END_BEFORE_4_02_0@ (** @since 4.02.0: external raise_notrace : exn -> 'a = "%raise_notrace" *) @BEGIN_FROM_4_02_0@ external __LOC__ : string = "%loc_LOC" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __LOC__ : string @END_BEFORE_4_02_0@ (** @since 4.02.0: external __LOC__ : string = "%loc_LOC" *) @BEGIN_FROM_4_02_0@ external __FILE__ : string = "%loc_FILE" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __FILE__ : string @END_BEFORE_4_02_0@ (** @since 4.02.0: external __FILE__ : string = "%loc_FILE" *) @BEGIN_FROM_4_02_0@ external __LINE__ : int = "%loc_LINE" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __LINE__ : int @END_BEFORE_4_02_0@ (** @since 4.02.0: external __LINE__ : int = "%loc_LINE" *) @BEGIN_FROM_4_02_0@ external __MODULE__ : string = "%loc_MODULE" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __MODULE__ : string @END_BEFORE_4_02_0@ (** @since 4.02.0: external __MODULE__ : string = "%loc_MODULE" *) @BEGIN_FROM_4_02_0@ external __POS__ : (string * int * int * int) = "%loc_POS" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __POS__ : (string * int * int * int) @END_BEFORE_4_02_0@ (** @since 4.02.0: external __POS__ : (string * int * int * int) = "%loc_POS" *) @BEGIN_FROM_4_02_0@ external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __LOC_OF__ : 'a -> (string * 'a) @END_BEFORE_4_02_0@ (** @since 4.02.0: external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC" *) @BEGIN_FROM_4_02_0@ external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __LINE_OF__ : 'a -> (int * 'a) @END_BEFORE_4_02_0@ (** @since 4.02.0: external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE" *) @BEGIN_FROM_4_02_0@ external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val __POS_OF__ : 'a -> ((string * int * int * int) * 'a) @END_BEFORE_4_02_0@ (** @since 4.02.0: external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS" *) @BEGIN_FROM_4_02_0@ val print_bytes : bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val print_bytes : Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val print_bytes : bytes -> unit *) @BEGIN_FROM_4_02_0@ val prerr_bytes : bytes -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val prerr_bytes : Stdcompat__init.bytes -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val prerr_bytes : bytes -> unit *) @BEGIN_FROM_4_01_0@ external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ val (|>) : 'a -> ('a -> 'b) -> 'b @END_BEFORE_4_01_0@ (** @since 4.01.0: external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply" *) @BEGIN_FROM_4_01_0@ external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ val (@@) : ('a -> 'b) -> 'a -> 'b @END_BEFORE_4_01_0@ (** @since 4.01.0: external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply" *) @BEGIN_FROM_4_03_0@ external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_00_0@ external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val hypot : float -> float -> float @END_BEFORE_4_00_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot"[@@unboxed ] [@@noalloc ] @since 4.00.0: external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot" "float" *) @BEGIN_FROM_4_03_0@ external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_00_0@ external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val copysign : float -> float -> float @END_BEFORE_4_00_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign" [@@unboxed ][@@noalloc ] @since 4.00.0: external copysign : float -> float -> float = "caml_copysign_float" "caml_copysign" "float" *) external (~+) : int -> int = "%identity" (** @since 3.12.0: external (~+) : int -> int = "%identity" *) external (~+.) : float -> float = "%identity" (** @since 3.12.0: external (~+.) : float -> float = "%identity" *) @BEGIN_FROM_4_03_0@ external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_12_0@ external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ val expm1 : float -> float @END_BEFORE_3_12_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external expm1 : float -> float = "caml_expm1_float" "caml_expm1" [@@unboxed ][@@noalloc ] @since 3.12.0: external expm1 : float -> float = "caml_expm1_float" "caml_expm1" "float" *) @BEGIN_FROM_4_03_0@ external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_12_0@ external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" @END_FROM_3_12_0@ @BEGIN_BEFORE_3_12_0@ val log1p : float -> float @END_BEFORE_3_12_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external log1p : float -> float = "caml_log1p_float" "caml_log1p" [@@unboxed ][@@noalloc ] @since 3.12.0: external log1p : float -> float = "caml_log1p_float" "caml_log1p" "float" *) external raise : exn -> 'a = "%raise" (** Alias for {!Stdlib.raise} *) val invalid_arg : string -> 'a (** Alias for {!Stdlib.invalid_arg} *) val failwith : string -> 'a (** Alias for {!Stdlib.failwith} *) external (=) : 'a -> 'a -> bool = "%equal" (** Alias for {!Stdlib.=} *) external (<>) : 'a -> 'a -> bool = "%notequal" (** Alias for {!Stdlib.<>} *) external (<) : 'a -> 'a -> bool = "%lessthan" (** Alias for {!Stdlib.<} *) external (>) : 'a -> 'a -> bool = "%greaterthan" (** Alias for {!Stdlib.>} *) external (<=) : 'a -> 'a -> bool = "%lessequal" (** Alias for {!Stdlib.<=} *) external (>=) : 'a -> 'a -> bool = "%greaterequal" (** Alias for {!Stdlib.>=} *) external compare : 'a -> 'a -> int = "%compare" (** Alias for {!Stdlib.compare} *) val min : 'a -> 'a -> 'a (** Alias for {!Stdlib.min} *) val max : 'a -> 'a -> 'a (** Alias for {!Stdlib.max} *) external (==) : 'a -> 'a -> bool = "%eq" (** Alias for {!Stdlib.==} *) external (!=) : 'a -> 'a -> bool = "%noteq" (** Alias for {!Stdlib.!=} *) external not : bool -> bool = "%boolnot" (** Alias for {!Stdlib.not} *) external (&&) : bool -> bool -> bool = "%sequand" (** Alias for {!Stdlib.&&} *) (** @since 4.02.0: external (&) : bool -> bool -> bool = "%sequand"[@@ocaml.deprecated "Use (&&) instead."] @since 3.07.0: external (&) : bool -> bool -> bool = "%sequand" *) external (||) : bool -> bool -> bool = "%sequor" (** Alias for {!Stdlib.||} *) (** @since 4.02.0: external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] @since 3.07.0: external (or) : bool -> bool -> bool = "%sequor" *) external (~-) : int -> int = "%negint" (** Alias for {!Stdlib.~-} *) external succ : int -> int = "%succint" (** Alias for {!Stdlib.succ} *) external pred : int -> int = "%predint" (** Alias for {!Stdlib.pred} *) external (+) : int -> int -> int = "%addint" (** Alias for {!Stdlib.+} *) external (-) : int -> int -> int = "%subint" (** Alias for {!Stdlib.-} *) external ( * ) : int -> int -> int = "%mulint" (** Alias for {!Stdlib.*} *) external (/) : int -> int -> int = "%divint" (** Alias for {!Stdlib./} *) external (mod) : int -> int -> int = "%modint" (** Alias for {!Stdlib.mod} *) val abs : int -> int (** Alias for {!Stdlib.abs} *) val max_int : int (** Alias for {!Stdlib.max_int} *) val min_int : int (** Alias for {!Stdlib.min_int} *) external (land) : int -> int -> int = "%andint" (** Alias for {!Stdlib.land} *) external (lor) : int -> int -> int = "%orint" (** Alias for {!Stdlib.lor} *) external (lxor) : int -> int -> int = "%xorint" (** Alias for {!Stdlib.lxor} *) val lnot : int -> int (** Alias for {!Stdlib.lnot} *) external (lsl) : int -> int -> int = "%lslint" (** Alias for {!Stdlib.lsl} *) external (lsr) : int -> int -> int = "%lsrint" (** Alias for {!Stdlib.lsr} *) external (asr) : int -> int -> int = "%asrint" (** Alias for {!Stdlib.asr} *) external (~-.) : float -> float = "%negfloat" (** Alias for {!Stdlib.~-.} *) external (+.) : float -> float -> float = "%addfloat" (** Alias for {!Stdlib.+.} *) external (-.) : float -> float -> float = "%subfloat" (** Alias for {!Stdlib.-.} *) external ( *. ) : float -> float -> float = "%mulfloat" (** Alias for {!Stdlib.*.} *) external (/.) : float -> float -> float = "%divfloat" (** Alias for {!Stdlib./.} *) @BEGIN_FROM_4_03_0@ external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external ( ** ) : float -> float -> float = "power_float" "pow" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external ( ** ) : float -> float -> float = "caml_power_float" "pow" [@@unboxed ][@@noalloc ] @since 3.08.0: external ( ** ) : float -> float -> float = "caml_power_float" "pow" "float" @since 3.07.0: external ( ** ) : float -> float -> float = "power_float" "pow" "float" *) @BEGIN_FROM_4_03_0@ external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sqrt : float -> float = "sqrt_float" "sqrt" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ] [@@noalloc ] @since 3.08.0: external sqrt : float -> float = "caml_sqrt_float" "sqrt" "float" @since 3.07.0: external sqrt : float -> float = "sqrt_float" "sqrt" "float" *) @BEGIN_FROM_4_03_0@ external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external exp : float -> float = "caml_exp_float" "exp" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external exp : float -> float = "exp_float" "exp" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ] [@@noalloc ] @since 3.08.0: external exp : float -> float = "caml_exp_float" "exp" "float" @since 3.07.0: external exp : float -> float = "exp_float" "exp" "float" *) @BEGIN_FROM_4_03_0@ external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external log : float -> float = "caml_log_float" "log" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external log : float -> float = "log_float" "log" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external log : float -> float = "caml_log_float" "log"[@@unboxed ] [@@noalloc ] @since 3.08.0: external log : float -> float = "caml_log_float" "log" "float" @since 3.07.0: external log : float -> float = "log_float" "log" "float" *) @BEGIN_FROM_4_03_0@ external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external log10 : float -> float = "caml_log10_float" "log10" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external log10 : float -> float = "log10_float" "log10" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ] [@@noalloc ] @since 3.08.0: external log10 : float -> float = "caml_log10_float" "log10" "float" @since 3.07.0: external log10 : float -> float = "log10_float" "log10" "float" *) @BEGIN_FROM_4_03_0@ external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external cos : float -> float = "caml_cos_float" "cos" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external cos : float -> float = "cos_float" "cos" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ] [@@noalloc ] @since 3.08.0: external cos : float -> float = "caml_cos_float" "cos" "float" @since 3.07.0: external cos : float -> float = "cos_float" "cos" "float" *) @BEGIN_FROM_4_03_0@ external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sin : float -> float = "caml_sin_float" "sin" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sin : float -> float = "sin_float" "sin" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ] [@@noalloc ] @since 3.08.0: external sin : float -> float = "caml_sin_float" "sin" "float" @since 3.07.0: external sin : float -> float = "sin_float" "sin" "float" *) @BEGIN_FROM_4_03_0@ external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external tan : float -> float = "caml_tan_float" "tan" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external tan : float -> float = "tan_float" "tan" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ] [@@noalloc ] @since 3.08.0: external tan : float -> float = "caml_tan_float" "tan" "float" @since 3.07.0: external tan : float -> float = "tan_float" "tan" "float" *) @BEGIN_FROM_4_03_0@ external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external acos : float -> float = "caml_acos_float" "acos" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external acos : float -> float = "acos_float" "acos" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ] [@@noalloc ] @since 3.08.0: external acos : float -> float = "caml_acos_float" "acos" "float" @since 3.07.0: external acos : float -> float = "acos_float" "acos" "float" *) @BEGIN_FROM_4_03_0@ external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external asin : float -> float = "caml_asin_float" "asin" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external asin : float -> float = "asin_float" "asin" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ] [@@noalloc ] @since 3.08.0: external asin : float -> float = "caml_asin_float" "asin" "float" @since 3.07.0: external asin : float -> float = "asin_float" "asin" "float" *) @BEGIN_FROM_4_03_0@ external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external atan : float -> float = "caml_atan_float" "atan" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external atan : float -> float = "atan_float" "atan" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ] [@@noalloc ] @since 3.08.0: external atan : float -> float = "caml_atan_float" "atan" "float" @since 3.07.0: external atan : float -> float = "atan_float" "atan" "float" *) @BEGIN_FROM_4_03_0@ external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external atan2 : float -> float -> float = "atan2_float" "atan2" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external atan2 : float -> float -> float = "caml_atan2_float" "atan2" [@@unboxed ][@@noalloc ] @since 3.08.0: external atan2 : float -> float -> float = "caml_atan2_float" "atan2" "float" @since 3.07.0: external atan2 : float -> float -> float = "atan2_float" "atan2" "float" *) @BEGIN_FROM_4_03_0@ external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external cosh : float -> float = "caml_cosh_float" "cosh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external cosh : float -> float = "cosh_float" "cosh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ] [@@noalloc ] @since 3.08.0: external cosh : float -> float = "caml_cosh_float" "cosh" "float" @since 3.07.0: external cosh : float -> float = "cosh_float" "cosh" "float" *) @BEGIN_FROM_4_03_0@ external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external sinh : float -> float = "caml_sinh_float" "sinh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external sinh : float -> float = "sinh_float" "sinh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ] [@@noalloc ] @since 3.08.0: external sinh : float -> float = "caml_sinh_float" "sinh" "float" @since 3.07.0: external sinh : float -> float = "sinh_float" "sinh" "float" *) @BEGIN_FROM_4_03_0@ external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external tanh : float -> float = "caml_tanh_float" "tanh" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external tanh : float -> float = "tanh_float" "tanh" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ] [@@noalloc ] @since 3.08.0: external tanh : float -> float = "caml_tanh_float" "tanh" "float" @since 3.07.0: external tanh : float -> float = "tanh_float" "tanh" "float" *) @BEGIN_FROM_4_03_0@ external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ceil : float -> float = "caml_ceil_float" "ceil" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external ceil : float -> float = "ceil_float" "ceil" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ] [@@noalloc ] @since 3.08.0: external ceil : float -> float = "caml_ceil_float" "ceil" "float" @since 3.07.0: external ceil : float -> float = "ceil_float" "ceil" "float" *) @BEGIN_FROM_4_03_0@ external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external floor : float -> float = "caml_floor_float" "floor" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external floor : float -> float = "floor_float" "floor" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ] [@@noalloc ] @since 3.08.0: external floor : float -> float = "caml_floor_float" "floor" "float" @since 3.07.0: external floor : float -> float = "floor_float" "floor" "float" *) external abs_float : float -> float = "%absfloat" (** Alias for {!Stdlib.abs_float} *) @BEGIN_FROM_4_03_0@ external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external mod_float : float -> float -> float = "fmod_float" "fmod" "float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external mod_float : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] @since 3.08.0: external mod_float : float -> float -> float = "caml_fmod_float" "fmod" "float" @since 3.07.0: external mod_float : float -> float -> float = "fmod_float" "fmod" "float" *) @BEGIN_FROM_3_08_0@ external frexp : float -> (float * int) = "caml_frexp_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external frexp : float -> (float * int) = "frexp_float" @END_BEFORE_3_08_0@ (** @since 3.08.0: external frexp : float -> (float * int) = "caml_frexp_float" @since 3.07.0: external frexp : float -> (float * int) = "frexp_float" *) @BEGIN_FROM_4_03_0@ external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external ldexp : float -> int -> float = "caml_ldexp_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external ldexp : float -> int -> float = "ldexp_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external ldexp : ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) = "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ] @since 3.08.0: external ldexp : float -> int -> float = "caml_ldexp_float" @since 3.07.0: external ldexp : float -> int -> float = "ldexp_float" *) @BEGIN_FROM_3_08_0@ external modf : float -> (float * float) = "caml_modf_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external modf : float -> (float * float) = "modf_float" @END_BEFORE_3_08_0@ (** @since 3.08.0: external modf : float -> (float * float) = "caml_modf_float" @since 3.07.0: external modf : float -> (float * float) = "modf_float" *) external float : int -> float = "%floatofint" (** Alias for {!Stdlib.float} *) external float_of_int : int -> float = "%floatofint" (** Alias for {!Stdlib.float_of_int} *) external truncate : float -> int = "%intoffloat" (** Alias for {!Stdlib.truncate} *) external int_of_float : float -> int = "%intoffloat" (** Alias for {!Stdlib.int_of_float} *) val infinity : float (** Alias for {!Stdlib.infinity} *) val neg_infinity : float (** Alias for {!Stdlib.neg_infinity} *) val nan : float (** Alias for {!Stdlib.nan} *) val max_float : float (** Alias for {!Stdlib.max_float} *) val min_float : float (** Alias for {!Stdlib.min_float} *) val epsilon_float : float (** Alias for {!Stdlib.epsilon_float} *) @BEGIN_FROM_4_03_0@ external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external classify_float : float -> fpclass = "caml_classify_float" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external classify_float : float -> fpclass = "classify_float" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] @since 3.08.0: external classify_float : float -> fpclass = "caml_classify_float" @since 3.07.0: external classify_float : float -> fpclass = "classify_float" *) val (^) : string -> string -> string (** Alias for {!Stdlib.^} *) external int_of_char : char -> int = "%identity" (** Alias for {!Stdlib.int_of_char} *) val char_of_int : int -> char (** Alias for {!Stdlib.char_of_int} *) external ignore : 'a -> unit = "%ignore" (** Alias for {!Stdlib.ignore} *) val string_of_bool : bool -> string (** Alias for {!Stdlib.string_of_bool} *) val bool_of_string : string -> bool (** Alias for {!Stdlib.bool_of_string} *) val string_of_int : int -> string (** Alias for {!Stdlib.string_of_int} *) @BEGIN_FROM_3_08_0@ external int_of_string : string -> int = "caml_int_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external int_of_string : string -> int = "int_of_string" @END_BEFORE_3_08_0@ (** @since 3.08.0: external int_of_string : string -> int = "caml_int_of_string" @since 3.07.0: external int_of_string : string -> int = "int_of_string" *) val string_of_float : float -> string (** Alias for {!Stdlib.string_of_float} *) @BEGIN_FROM_3_08_0@ external float_of_string : string -> float = "caml_float_of_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external float_of_string : string -> float = "float_of_string" @END_BEFORE_3_08_0@ (** @since 3.08.0: external float_of_string : string -> float = "caml_float_of_string" @since 3.07.0: external float_of_string : string -> float = "float_of_string" *) @BEGIN_WITH_FLAMBDA2@ external fst : ('a * 'b) -> 'a = "%field0_immut" (** Alias for {!Stdlib.fst} *) external snd : ('a * 'b) -> 'b = "%field1_immut" (** Alias for {!Stdlib.snd} *) @END_WITH_FLAMBDA2@ @BEGIN_WITHOUT_FLAMBDA2@ external fst : ('a * 'b) -> 'a = "%field0" (** Alias for {!Stdlib.fst} *) external snd : ('a * 'b) -> 'b = "%field1" (** Alias for {!Stdlib.snd} *) @END_WITHOUT_FLAMBDA2@ val (@) : 'a list -> 'a list -> 'a list (** Alias for {!Stdlib.@} *) val print_char : char -> unit (** Alias for {!Stdlib.print_char} *) val print_string : string -> unit (** Alias for {!Stdlib.print_string} *) val print_int : int -> unit (** Alias for {!Stdlib.print_int} *) val print_float : float -> unit (** Alias for {!Stdlib.print_float} *) val print_endline : string -> unit (** Alias for {!Stdlib.print_endline} *) val print_newline : unit -> unit (** Alias for {!Stdlib.print_newline} *) val prerr_char : char -> unit (** Alias for {!Stdlib.prerr_char} *) val prerr_string : string -> unit (** Alias for {!Stdlib.prerr_string} *) val prerr_int : int -> unit (** Alias for {!Stdlib.prerr_int} *) val prerr_float : float -> unit (** Alias for {!Stdlib.prerr_float} *) val prerr_endline : string -> unit (** Alias for {!Stdlib.prerr_endline} *) val prerr_newline : unit -> unit (** Alias for {!Stdlib.prerr_newline} *) val read_line : unit -> string (** Alias for {!Stdlib.read_line} *) val read_int : unit -> int (** Alias for {!Stdlib.read_int} *) val read_float : unit -> float (** Alias for {!Stdlib.read_float} *) val flush_all : unit -> unit (** Alias for {!Stdlib.flush_all} *) external ref : 'a -> 'a ref = "%makemutable" (** Alias for {!Stdlib.ref} *) external (!) : 'a ref -> 'a = "%field0" (** Alias for {!Stdlib.!} *) external (:=) : 'a ref -> 'a -> unit = "%setfield0" (** Alias for {!Stdlib.:=} *) external incr : int ref -> unit = "%incr" (** Alias for {!Stdlib.incr} *) external decr : int ref -> unit = "%decr" (** Alias for {!Stdlib.decr} *) @BEGIN_FROM_3_10_0@ external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" @END_FROM_3_10_0@ @BEGIN_BEFORE_3_10_0@ external format_of_string : ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd) format4 = "%identity" @END_BEFORE_3_10_0@ (** @since 3.10.0: external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 = "%identity" @since 3.07.0: external format_of_string : ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd) format4 = "%identity" *) val exit : int -> 'a (** Alias for {!Stdlib.exit} *) val at_exit : (unit -> unit) -> unit (** Alias for {!Stdlib.at_exit} *) val valid_float_lexem : string -> string (** Alias for {!Stdlib.valid_float_lexem} *) val do_at_exit : unit -> unit (** Alias for {!Stdlib>.do_at_exit} *) end ocaml-stdcompat-20~git20240529/stdcompat__printexc.ml.in000066400000000000000000000114511463722102200231270ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Printexc @END_FROM_4_08_0@ @BEGIN_BEFORE_4_12_0@ @BEGIN_FROM_3_11_0@ type raw_backtrace_entry = private int @END_FROM_3_11_0@ @BEGIN_BEFORE_3_11_0@ type raw_backtrace_entry = int @END_BEFORE_3_11_0@ let not_implemented () = failwith "Stdcompat: not implemented." let backtrace_slots_of_raw_entry _ = not_implemented () let raw_backtrace_entries _ = not_implemented () @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ type t = exn = .. @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = exn @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ @BEGIN_FROM_4_01_0@ type raw_backtrace = Printexc.raw_backtrace @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ type raw_backtrace = unit @END_BEFORE_4_01_0@ @BEGIN_FROM_4_02_0@ type backtrace_slot = Printexc.backtrace_slot @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type backtrace_slot @END_BEFORE_4_02_0@ type location = @BEGIN_FROM_5_2_0@ Printexc.location = @END_FROM_5_2_0@ { filename: string ; line_number: int ; start_char: int ; end_char: int ; end_line: int ; end_col: int } let to_string = Printexc.to_string @BEGIN_BEFORE_4_09_0@ let use_printers e = Some (to_string e) let to_string_default e = to_string e @END_BEFORE_4_09_0@ @BEGIN_FROM_4_11_0@ module Slot = Printexc.Slot @END_FROM_4_11_0@ @BEGIN_BEFORE_4_11_0@ module Slot = struct @BEGIN_FROM_4_04_0@ include Printexc.Slot @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ type t = backtrace_slot @BEGIN_FROM_4_02_0@ let is_raise = Printexc.Slot.is_raise let location = Printexc.Slot.location let format = Printexc.Slot.format @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ let is_raise _ = false let location _ = None let format _ _ = None @END_BEFORE_4_02_0@ let is_inline _ = false @END_BEFORE_4_04_0@ let name _ = None end @END_BEFORE_4_11_0@ @BEGIN_FROM_4_02_0@ type raw_backtrace_slot = Printexc.raw_backtrace_slot @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type raw_backtrace_slot @END_BEFORE_4_02_0@ @BEGIN_FROM_4_05_0@ external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ let raise_with_backtrace exn _ = raise exn @END_BEFORE_4_05_0@ @BEGIN_FROM_4_04_0@ let get_raw_backtrace_next_slot = Printexc.get_raw_backtrace_next_slot @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ let get_raw_backtrace_next_slot _ = not_implemented () @END_BEFORE_4_04_0@ @BEGIN_FROM_4_02_0@ let set_uncaught_exception_handler = Printexc.set_uncaught_exception_handler let backtrace_slots = Printexc.backtrace_slots let raw_backtrace_length = Printexc.raw_backtrace_length let get_raw_backtrace_slot = Printexc.get_raw_backtrace_slot let convert_raw_backtrace_slot = Printexc.convert_raw_backtrace_slot let exn_slot_id = Printexc.exn_slot_id let exn_slot_name = Printexc.exn_slot_name @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ let set_uncaught_exception_handler _ = not_implemented () let backtrace_slots _ = not_implemented () let raw_backtrace_length _ = not_implemented () let get_raw_backtrace_slot _ = not_implemented () let convert_raw_backtrace_slot _ = not_implemented () let exn_slot_id _ = not_implemented () let exn_slot_name _ = not_implemented () @END_BEFORE_4_02_0@ @BEGIN_FROM_4_10_0@ external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" @END_FROM_4_10_0@ @BEGIN_BEFORE_4_10_0@ @BEGIN_FROM_4_01_0@ let get_callstack = Printexc.get_callstack @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ let get_callstack _ = not_implemented () @END_BEFORE_4_01_0@ @END_BEFORE_4_10_0@ @BEGIN_FROM_4_01_0@ let get_raw_backtrace = Printexc.get_raw_backtrace let print_raw_backtrace = Printexc.print_raw_backtrace let raw_backtrace_to_string = Printexc.raw_backtrace_to_string @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ let get_raw_backtrace _ = () let print_raw_backtrace _stderr _raw_backtrace = () let raw_backtrace_to_string _ = not_implemented () @END_BEFORE_4_01_0@ @BEGIN_FROM_3_11_0@ let print_backtrace = Printexc.print_backtrace let get_backtrace = Printexc.get_backtrace let record_backtrace = Printexc.record_backtrace let backtrace_status = Printexc.backtrace_status let register_printer = Printexc.register_printer @END_FROM_3_11_0@ @BEGIN_BEFORE_3_11_0@ let print_backtrace _ = not_implemented () let get_backtrace _ = not_implemented () let record_backtrace _ = not_implemented () let backtrace_status _ = not_implemented () let register_printer _ = not_implemented () @END_BEFORE_3_11_0@ let print = Printexc.print let catch = Printexc.catch @BEGIN_BEFORE_4_11_0@ let default_uncaught_exception_handler exn raw_backtrace = Printf.eprintf "Fatal error: exception %s\n" (to_string exn); print_raw_backtrace stderr raw_backtrace; flush stderr @END_BEFORE_4_11_0@ @BEGIN_BEFORE_5_0_0@ let string_of_extension_constructor _ = failwith "not implemented" @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__printexc.mli.in000066400000000000000000000000401463722102200232700ustar00rootroot00000000000000include Stdcompat__printexc_s.S ocaml-stdcompat-20~git20240529/stdcompat__printexc_s.mli.in000066400000000000000000000137531463722102200236310ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ @BEGIN_FROM_4_02_0@ type t = exn = .. @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = exn @END_BEFORE_4_02_0@ @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ type t = exn = .. @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = exn @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: type t = exn = .. *) @BEGIN_FROM_4_01_0@ type raw_backtrace = Printexc.raw_backtrace @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ type raw_backtrace @END_BEFORE_4_01_0@ (** @since 4.01.0: type raw_backtrace *) @BEGIN_FROM_4_12_0@ type raw_backtrace_entry = Printexc.raw_backtrace_entry @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ @BEGIN_FROM_3_11_0@ type raw_backtrace_entry = private int @END_FROM_3_11_0@ @BEGIN_BEFORE_3_11_0@ type raw_backtrace_entry = int @END_BEFORE_3_11_0@ @END_BEFORE_4_12_0@ (** @since 4.12.0: type raw_backtrace_entry = Printexc.raw_backtrace_entry *) @BEGIN_FROM_4_02_0@ type backtrace_slot = Printexc.backtrace_slot @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type backtrace_slot @END_BEFORE_4_02_0@ (** @since 4.02.0: type backtrace_slot *) @BEGIN_FROM_5_2_0@ type location = Printexc.location = { filename: string ; line_number: int ; start_char: int ; end_char: int ; end_line: int ; end_col: int } @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ type location = { filename: string ; line_number: int ; start_char: int ; end_char: int ; end_line: int ; end_col: int } @END_BEFORE_5_2_0@ (** @since 5.2.0: type location = { filename: string ; line_number: int ; start_char: int ; end_char: int ; end_line: int ; end_col: int } *) @BEGIN_FROM_4_11_0@ module Slot = Printexc.Slot @END_FROM_4_11_0@ @BEGIN_BEFORE_4_11_0@ module Slot : sig type t = backtrace_slot val is_raise : t -> bool val is_inline : t -> bool val location : t -> location option val name : t -> string option val format : int -> t -> string option end @END_BEFORE_4_11_0@ (** @since 4.11.0: module Slot = Printexc.Slot *) @BEGIN_FROM_4_02_0@ type raw_backtrace_slot = Printexc.raw_backtrace_slot @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type raw_backtrace_slot @END_BEFORE_4_02_0@ (** @since 4.02.0: type raw_backtrace_slot *) val string_of_extension_constructor : Obj.t -> string (** @since 5.0.0: val string_of_extension_constructor : Obj.t -> string *) val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array (** @since 4.12.0: val raw_backtrace_entries : raw_backtrace -> raw_backtrace_entry array *) val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option (** @since 4.12.0: val backtrace_slots_of_raw_entry : raw_backtrace_entry -> backtrace_slot array option *) val default_uncaught_exception_handler : exn -> raw_backtrace -> unit (** @since 4.11.0: val default_uncaught_exception_handler : exn -> raw_backtrace -> unit *) val to_string_default : exn -> string (** @since 4.09.0: val to_string_default : exn -> string *) val use_printers : exn -> string option (** @since 4.09.0: val use_printers : exn -> string option *) @BEGIN_FROM_4_05_0@ external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val raise_with_backtrace : exn -> raw_backtrace -> 'a @END_BEFORE_4_05_0@ (** @since 4.05.0: external raise_with_backtrace : exn -> raw_backtrace -> 'a = "%raise_with_backtrace" *) val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option (** @since 4.04.0: val get_raw_backtrace_next_slot : raw_backtrace_slot -> raw_backtrace_slot option *) val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit (** @since 4.02.0: val set_uncaught_exception_handler : (exn -> raw_backtrace -> unit) -> unit *) val backtrace_slots : raw_backtrace -> backtrace_slot array option (** @since 4.02.0: val backtrace_slots : raw_backtrace -> backtrace_slot array option *) val raw_backtrace_length : raw_backtrace -> int (** @since 4.02.0: val raw_backtrace_length : raw_backtrace -> int *) val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot (** @since 4.02.0: val get_raw_backtrace_slot : raw_backtrace -> int -> raw_backtrace_slot *) val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot (** @since 4.02.0: val convert_raw_backtrace_slot : raw_backtrace_slot -> backtrace_slot *) val exn_slot_id : exn -> int (** @since 4.02.0: val exn_slot_id : exn -> int *) val exn_slot_name : exn -> string (** @since 4.02.0: val exn_slot_name : exn -> string *) val get_raw_backtrace : unit -> raw_backtrace (** @since 4.01.0: val get_raw_backtrace : unit -> raw_backtrace *) val print_raw_backtrace : out_channel -> raw_backtrace -> unit (** @since 4.01.0: val print_raw_backtrace : out_channel -> raw_backtrace -> unit *) val raw_backtrace_to_string : raw_backtrace -> string (** @since 4.01.0: val raw_backtrace_to_string : raw_backtrace -> string *) @BEGIN_FROM_4_10_0@ external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" @END_FROM_4_10_0@ @BEGIN_BEFORE_4_10_0@ val get_callstack : int -> raw_backtrace @END_BEFORE_4_10_0@ (** @since 4.10.0: external get_callstack : int -> raw_backtrace = "caml_get_current_callstack" @since 4.01.0: val get_callstack : int -> raw_backtrace *) val print_backtrace : out_channel -> unit (** @since 3.11.0: val print_backtrace : out_channel -> unit *) val get_backtrace : unit -> string (** @since 3.11.0: val get_backtrace : unit -> string *) val record_backtrace : bool -> unit (** @since 3.11.0: val record_backtrace : bool -> unit *) val backtrace_status : unit -> bool (** @since 3.11.0: val backtrace_status : unit -> bool *) val register_printer : (exn -> string option) -> unit (** @since 3.11.0: val register_printer : (exn -> string option) -> unit *) val to_string : exn -> string (** Alias for {!Printexc.to_string} *) val print : ('a -> 'b) -> 'a -> 'b (** Alias for {!Printexc.print} *) val catch : ('a -> 'b) -> 'a -> 'b (** Alias for {!Printexc.catch} *) end ocaml-stdcompat-20~git20240529/stdcompat__printf.ml.in000066400000000000000000000010131463722102200225660ustar00rootroot00000000000000@BEGIN_BEFORE_4_11_0@ let not_implemented _ = failwith "Stdcompat.Printf is not implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." let ikbprintf = not_implemented let ibprintf = not_implemented @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_02_0@ let ifprintf = not_implemented let kbprintf = not_implemented let kfprintf = not_implemented let ksprintf = not_implemented @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_01_0@ let ikfprintf = not_implemented @END_BEFORE_4_01_0@ include Printf ocaml-stdcompat-20~git20240529/stdcompat__printf.mli.in000066400000000000000000000000361463722102200227430ustar00rootroot00000000000000include Stdcompat__printf_s.S ocaml-stdcompat-20~git20240529/stdcompat__printf_s.mli.in000066400000000000000000000101551463722102200232700ustar00rootroot00000000000000module type S = sig val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a (** @since 4.11.0: val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a *) val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a (** @since 4.11.0: val ikbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a *) @BEGIN_FROM_4_03_0@ val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a (** @since 4.03.0: val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a *) @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_10_0@ val ifprintf : 'b -> ('a, 'b, unit) format -> 'a @END_FROM_3_10_0@ @BEGIN_BEFORE_3_10_0@ val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a @END_BEFORE_3_10_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a *) @BEGIN_FROM_4_03_0@ val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a (** @since 4.03.0: val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a *) @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_01_0@ val ikfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a @END_BEFORE_4_01_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: val ikfprintf : ('b -> 'd) -> 'b -> ('a, 'b, 'c, 'd) format4 -> 'a *) @BEGIN_FROM_4_03_0@ val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_10_0@ val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b @END_FROM_3_10_0@ @BEGIN_BEFORE_3_10_0@ val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a @END_BEFORE_3_10_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: val kbprintf : (Buffer.t -> 'd) -> Buffer.t -> ('a, Buffer.t, unit, 'd) format4 -> 'a @since 3.10.0: val kbprintf : (Buffer.t -> 'a) -> Buffer.t -> ('b, Buffer.t, unit, 'a) format4 -> 'b *) @BEGIN_FROM_4_03_0@ val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_09_0@ val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b @END_FROM_3_09_0@ @BEGIN_BEFORE_3_09_0@ val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a @END_BEFORE_3_09_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: val kfprintf : (out_channel -> 'd) -> out_channel -> ('a, out_channel, unit, 'd) format4 -> 'a @since 3.09.0: val kfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b *) @BEGIN_FROM_4_03_0@ val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_09_0@ val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b @END_FROM_3_09_0@ @BEGIN_BEFORE_3_09_0@ val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a @END_BEFORE_3_09_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: val ksprintf : (string -> 'd) -> ('a, unit, string, 'd) format4 -> 'a @since 3.09.0: val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b *) val fprintf : out_channel -> ('a, out_channel, unit) format -> 'a (** Alias for {!Printf.fprintf} *) val printf : ('a, out_channel, unit) format -> 'a (** Alias for {!Printf.printf} *) val eprintf : ('a, out_channel, unit) format -> 'a (** Alias for {!Printf.eprintf} *) val sprintf : ('a, unit, string) format -> 'a (** Alias for {!Printf.sprintf} *) val bprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a (** Alias for {!Printf.bprintf} *) @BEGIN_FROM_4_03_0@ val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b @END_BEFORE_4_03_0@ (** @since 4.03.0: val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a @since 3.07.0: val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b *) end ocaml-stdcompat-20~git20240529/stdcompat__queue.ml.in000066400000000000000000000031301463722102200224120ustar00rootroot00000000000000include Queue @BEGIN_BEFORE_4_08_0@ let take_opt q = try Some (take q) with Empty -> raise Empty let peek_opt q = try Some (peek q) with Empty -> raise Empty @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_07_0@ @BEGIN_WITH_MAGIC@ @BEGIN_FROM_4_03_0@ @BEGIN_FROM_4_00_0@ [@@@ocaml.warning "-37"] @END_FROM_4_00_0@ type 'a cell = | Nil | Cons of { content: 'a; mutable next: 'a cell } type 'a internal = { mutable length: int; mutable first: 'a cell; mutable last: 'a cell } let to_seq (q : 'a t) = let q : 'a internal = Obj.magic q in let rec aux c () = match c with | Nil -> Stdcompat__seq.Nil | Cons { content=x; next; } -> Stdcompat__seq.Cons (x, aux next) in aux q.first @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ type 'a cell = { content: 'a; mutable next: 'a cell } type 'a internal = { mutable length: int; mutable tail: 'a cell } let to_seq (q : 'a t) = let q : 'a internal = Obj.magic q in if q.length = 0 then Stdcompat__seq.empty else begin let tail = q.tail in let rec aux cell () = let tail' = if cell == tail then Stdcompat__seq.empty else aux cell.next in Stdcompat__seq.Cons (cell.content, tail') in aux tail.next end @END_BEFORE_4_03_0@ @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_list q = fold (fun accu content -> content :: accu) [] q let to_seq q = Stdcompat__list.to_seq (List.rev (to_list q)) @END_WITHOUT_MAGIC@ let add_seq q i = Stdcompat__seq.iter (fun x -> push x q) i let of_seq g = let q = create() in add_seq q g; q @END_BEFORE_4_07_0@ ocaml-stdcompat-20~git20240529/stdcompat__queue.mli.in000066400000000000000000000000351463722102200225640ustar00rootroot00000000000000include Stdcompat__queue_s.S ocaml-stdcompat-20~git20240529/stdcompat__queue_s.mli.in000066400000000000000000000044441463722102200231160ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_12_0@ type !'a t = 'a Queue.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a Queue.t @END_BEFORE_4_12_0@ (** Alias for {!Queue.t} *) exception Empty (** Alias for {!Queue.Empty} *) val take_opt : 'a t -> 'a option (** @since 4.08.0: val take_opt : 'a t -> 'a option *) val peek_opt : 'a t -> 'a option (** @since 4.08.0: val peek_opt : 'a t -> 'a option *) @BEGIN_FROM_4_07_0@ val to_seq : 'a t -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a t -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : 'a t -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val add_seq : 'a t -> 'a Seq.t -> unit @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val add_seq : 'a t -> 'a Stdcompat__seq.t -> unit @END_BEFORE_4_07_0@ (** @since 4.07.0: val add_seq : 'a t -> 'a Seq.t -> unit *) @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : 'a Seq.t -> 'a t *) val create : unit -> 'a t (** Alias for {!Queue.create} *) val add : 'a -> 'a t -> unit (** Alias for {!Queue.add} *) val push : 'a -> 'a t -> unit (** Alias for {!Queue.push} *) val take : 'a t -> 'a (** Alias for {!Queue.take} *) val pop : 'a t -> 'a (** Alias for {!Queue.pop} *) val peek : 'a t -> 'a (** Alias for {!Queue.peek} *) val top : 'a t -> 'a (** Alias for {!Queue.top} *) val clear : 'a t -> unit (** Alias for {!Queue.clear} *) val copy : 'a t -> 'a t (** Alias for {!Queue.copy} *) val is_empty : 'a t -> bool (** Alias for {!Queue.is_empty} *) val length : 'a t -> int (** Alias for {!Queue.length} *) val iter : ('a -> unit) -> 'a t -> unit (** Alias for {!Queue.iter} *) @BEGIN_FROM_5_1_0@ val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_00_0@ val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a @END_BEFORE_4_00_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @since 4.00.0: val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b @since 3.07.0: val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a *) val transfer : 'a t -> 'a t -> unit (** Alias for {!Queue.transfer} *) end ocaml-stdcompat-20~git20240529/stdcompat__random.ml.in000066400000000000000000000063041463722102200225540ustar00rootroot00000000000000@BEGIN_FROM_5_2_0@ include Random @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module State = struct include Random.State let int_in_range state ~min ~max = if min > max then raise (Invalid_argument "int_in_range"); min + int state (max - min + 1) let int32_in_range state ~min ~max = if Int32.compare min max > 0 then raise (Invalid_argument "int32_in_range"); let ( + ), ( - ) = Int32.(add, sub) in min + int32 state (max - min + 1l) let nativeint_in_range state ~min ~max = if Nativeint.compare min max > 0 then raise (Invalid_argument "nativeint_in_range"); let ( + ), ( - ) = Nativeint.(add, sub) in min + nativeint state (max - min + 1n) let int64_in_range state ~min ~max = if Int64.compare min max > 0 then raise (Invalid_argument "int64_in_range"); let ( + ), ( - ) = Int64.(add, sub) in min + int64 state (max - min + 1L) @BEGIN_BEFORE_4_14_0@ let bits32 state = let bits30 = Int32.of_int (bits state) in let add_bit bits i = if bool state then Int32.add bits (Int32.shift_left 1l i) else bits in let bits31 = add_bit bits30 30 in let bits32 = add_bit bits31 31 in bits32 let bits64 state = let bits30 = Int64.of_int (bits state) in let bits60 = Int64.add bits30 (Int64.shift_left (Int64.of_int (bits state)) 30) in let add_bit bits i = if bool state then Int64.add bits (Int64.shift_left 1L i) else bits in let bits61 = add_bit bits60 60 in let bits62 = add_bit bits61 61 in let bits63 = add_bit bits62 62 in let bits64 = add_bit bits63 63 in bits64 let nativebits state = Int64.to_nativeint (bits64 state) @END_BEFORE_4_14_0@ @BEGIN_BEFORE_4_13_0@ let full_int state n = Int64.to_int (bits64 state) mod n @END_BEFORE_4_13_0@ @BEGIN_BEFORE_5_1_0@ let max_int31 = 0x3FFF_FFFF let split s = make [| int s max_int31; int s max_int31; int s max_int31; int s max_int31 |] let to_binary_string _ = failwith "not implemented" let of_binary_string _ = failwith "not implemented" @END_BEFORE_5_1_0@ end let init = Random.init let full_init = Random.full_init let self_init = Random.self_init let bits = Random.bits let int = Random.int let int32 = Random.int32 let nativeint = Random.nativeint let int64 = Random.int64 let float = Random.float let bool = Random.bool let get_state = Random.get_state let set_state = Random.set_state let int_in_range ~min ~max = State.int_in_range (get_state ()) ~min ~max let int32_in_range ~min ~max = State.int32_in_range (get_state ()) ~min ~max let nativeint_in_range ~min ~max = State.nativeint_in_range (get_state ()) ~min ~max let int64_in_range ~min ~max = State.int64_in_range (get_state ()) ~min ~max let bits32 () = State.bits32 (get_state ()) let bits64 () = State.bits64 (get_state ()) let nativebits () = State.nativebits (get_state ()) @BEGIN_FROM_4_13_0@ let full_int = Random.full_int @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ let full_int n = State.full_int (get_state ()) n @END_BEFORE_4_13_0@ @BEGIN_FROM_5_0_0@ let split = Random.split @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ let split () = get_state () @END_BEFORE_5_0_0@ @END_BEFORE_5_2_0@ ocaml-stdcompat-20~git20240529/stdcompat__random.mli.in000066400000000000000000000000361463722102200227210ustar00rootroot00000000000000include Stdcompat__random_s.S ocaml-stdcompat-20~git20240529/stdcompat__random_s.mli.in000066400000000000000000000051521463722102200232470ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_5_2_0@ module State = Random.State @END_FROM_5_2_0@ @BEGIN_BEFORE_5_2_0@ module State : sig type t val make : int array -> t val make_self_init : unit -> t val copy : t -> t val bits : t -> int val int : t -> int -> int val full_int : t -> int -> int val int_in_range : t -> min:int -> max:int -> int val int32 : t -> Int32.t -> Int32.t val int32_in_range : t -> min:int32 -> max:int32 -> int32 val nativeint : t -> Nativeint.t -> Nativeint.t val nativeint_in_range : t -> min:nativeint -> max:nativeint -> nativeint val int64 : t -> Int64.t -> Int64.t val int64_in_range : t -> min:int64 -> max:int64 -> int64 val float : t -> float -> float val bool : t -> bool val bits32 : t -> Int32.t val bits64 : t -> Int64.t val nativebits : t -> Nativeint.t val split : t -> t val to_binary_string : t -> string val of_binary_string : string -> t end @END_BEFORE_5_2_0@ (** @since 5.2.0: module State = Random.State *) val int_in_range : min:int -> max:int -> int (** @since 5.2.0: val int_in_range : min:int -> max:int -> int *) val int32_in_range : min:int32 -> max:int32 -> int32 (** @since 5.2.0: val int32_in_range : min:int32 -> max:int32 -> int32 *) val nativeint_in_range : min:nativeint -> max:nativeint -> nativeint (** @since 5.2.0: val nativeint_in_range : min:nativeint -> max:nativeint -> nativeint *) val int64_in_range : min:int64 -> max:int64 -> int64 (** @since 5.2.0: val int64_in_range : min:int64 -> max:int64 -> int64 *) val split : unit -> State.t (** @since 5.0.0: val split : unit -> State.t *) val bits32 : unit -> Int32.t (** @since 4.14.0: val bits32 : unit -> Int32.t *) val bits64 : unit -> Int64.t (** @since 4.14.0: val bits64 : unit -> Int64.t *) val nativebits : unit -> Nativeint.t (** @since 4.14.0: val nativebits : unit -> Nativeint.t *) val full_int : int -> int (** @since 4.13.0: val full_int : int -> int *) val init : int -> unit (** Alias for {!Random.init} *) val full_init : int array -> unit (** Alias for {!Random.full_init} *) val self_init : unit -> unit (** Alias for {!Random.self_init} *) val bits : unit -> int (** Alias for {!Random.bits} *) val int : int -> int (** Alias for {!Random.int} *) val int32 : Int32.t -> Int32.t (** Alias for {!Random.int32} *) val nativeint : Nativeint.t -> Nativeint.t (** Alias for {!Random.nativeint} *) val int64 : Int64.t -> Int64.t (** Alias for {!Random.int64} *) val float : float -> float (** Alias for {!Random.float} *) val bool : unit -> bool (** Alias for {!Random.bool} *) val get_state : unit -> State.t (** Alias for {!Random.get_state} *) val set_state : State.t -> unit (** Alias for {!Random.set_state} *) end ocaml-stdcompat-20~git20240529/stdcompat__result.ml.in000066400000000000000000000032741463722102200226150ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Stdlib.Result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type ('a, 'e) t = ('a, 'e) Stdcompat__pervasives.result = | Ok of 'a | Error of 'e let ok v = Ok v let error e = Error e let value r ~default = match r with | Ok v -> v | Error _ -> default let get_ok r = match r with | Ok v -> v | Error _ -> invalid_arg "result is Error _" let get_error r = match r with | Ok _ -> invalid_arg "result is Ok _" | Error e -> e let bind r f = match r with | Ok v -> f v | Error e -> Error e let join r = match r with | Ok v -> v | Error e -> Error e let map f r = match r with | Ok v -> Ok (f v) | Error e -> Error e let map_error f r = match r with | Ok v -> Ok v | Error e -> Error (f e) let fold ~ok ~error r = match r with | Ok v -> ok v | Error e -> error e let iter f r = match r with | Ok v -> f v | Error _ -> () let iter_error f r = match r with | Ok _ -> () | Error e -> f e let is_ok e = match e with | Ok _ -> true | Error _ -> false let is_error e = match e with | Ok _ -> false | Error _ -> true let equal ~ok ~error r r' = match r, r' with | Ok v, Ok v' -> ok v v' | Error e, Error e' -> error e e' | Ok _, Error _ | Error _, Ok _ -> false let compare ~ok ~error r r' = match r, r' with | Ok v, Ok v' -> ok v v' | Ok _, Error _ -> -1 | Error _, Ok _ -> 1 | Error e, Error e' -> error e e' let to_option r = match r with | Ok v -> Some v | Error _ -> None let to_list r = match r with | Ok v -> [v] | Error _ -> [] let to_seq r = match r with | Ok v -> fun () -> Stdcompat__seq.Cons (v, Stdcompat__seq.empty) | Error _ -> Stdcompat__seq.empty @END_BEFORE_4_08_0@ ocaml-stdcompat-20~git20240529/stdcompat__result.mli.in000066400000000000000000000000361463722102200227570ustar00rootroot00000000000000include Stdcompat__result_s.S ocaml-stdcompat-20~git20240529/stdcompat__result_s.mli.in000066400000000000000000000141071463722102200233050ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type ('a, 'e) t = ('a, 'e) Stdcompat__pervasives.result = | Ok of 'a | Error of 'e @END_BEFORE_4_08_0@ (** @since 4.08.0: type ('a, 'e) t = ('a, 'e) result = | Ok of 'a | Error of 'e *) @BEGIN_FROM_4_08_0@ val ok : 'a -> ('a, 'e) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val ok : 'a -> ('a, 'e) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val ok : 'a -> ('a, 'e) result *) @BEGIN_FROM_4_08_0@ val error : 'e -> ('a, 'e) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val error : 'e -> ('a, 'e) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val error : 'e -> ('a, 'e) result *) @BEGIN_FROM_4_08_0@ val value : ('a, 'e) result -> default:'a -> 'a @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val value : ('a, 'e) Stdcompat__pervasives.result -> default:'a -> 'a @END_BEFORE_4_08_0@ (** @since 4.08.0: val value : ('a, 'e) result -> default:'a -> 'a *) @BEGIN_FROM_4_08_0@ val get_ok : ('a, 'e) result -> 'a @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_ok : ('a, 'e) Stdcompat__pervasives.result -> 'a @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_ok : ('a, 'e) result -> 'a *) @BEGIN_FROM_4_08_0@ val get_error : ('a, 'e) result -> 'e @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val get_error : ('a, 'e) Stdcompat__pervasives.result -> 'e @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_error : ('a, 'e) result -> 'e *) @BEGIN_FROM_4_08_0@ val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val bind : ('a, 'e) Stdcompat__pervasives.result -> ('a -> ('b, 'e) Stdcompat__pervasives.result) -> ('b, 'e) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result *) @BEGIN_FROM_4_08_0@ val join : (('a, 'e) result, 'e) result -> ('a, 'e) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val join : (('a, 'e) Stdcompat__pervasives.result, 'e) Stdcompat__pervasives.result -> ('a, 'e) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val join : (('a, 'e) result, 'e) result -> ('a, 'e) result *) @BEGIN_FROM_4_08_0@ val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val map : ('a -> 'b) -> ('a, 'e) Stdcompat__pervasives.result -> ('b, 'e) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result *) @BEGIN_FROM_4_08_0@ val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val map_error : ('e -> 'f) -> ('a, 'e) Stdcompat__pervasives.result -> ('a, 'f) Stdcompat__pervasives.result @END_BEFORE_4_08_0@ (** @since 4.08.0: val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result *) @BEGIN_FROM_4_08_0@ val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) Stdcompat__pervasives.result -> 'c @END_BEFORE_4_08_0@ (** @since 4.08.0: val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c *) @BEGIN_FROM_4_08_0@ val iter : ('a -> unit) -> ('a, 'e) result -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val iter : ('a -> unit) -> ('a, 'e) Stdcompat__pervasives.result -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val iter : ('a -> unit) -> ('a, 'e) result -> unit *) @BEGIN_FROM_4_08_0@ val iter_error : ('e -> unit) -> ('a, 'e) result -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val iter_error : ('e -> unit) -> ('a, 'e) Stdcompat__pervasives.result -> unit @END_BEFORE_4_08_0@ (** @since 4.08.0: val iter_error : ('e -> unit) -> ('a, 'e) result -> unit *) @BEGIN_FROM_4_08_0@ val is_ok : ('a, 'e) result -> bool @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val is_ok : ('a, 'e) Stdcompat__pervasives.result -> bool @END_BEFORE_4_08_0@ (** @since 4.08.0: val is_ok : ('a, 'e) result -> bool *) @BEGIN_FROM_4_08_0@ val is_error : ('a, 'e) result -> bool @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val is_error : ('a, 'e) Stdcompat__pervasives.result -> bool @END_BEFORE_4_08_0@ (** @since 4.08.0: val is_error : ('a, 'e) result -> bool *) @BEGIN_FROM_4_08_0@ val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) Stdcompat__pervasives.result -> ('a, 'e) Stdcompat__pervasives.result -> bool @END_BEFORE_4_08_0@ (** @since 4.08.0: val equal : ok:('a -> 'a -> bool) -> error:('e -> 'e -> bool) -> ('a, 'e) result -> ('a, 'e) result -> bool *) @BEGIN_FROM_4_08_0@ val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) Stdcompat__pervasives.result -> ('a, 'e) Stdcompat__pervasives.result -> int @END_BEFORE_4_08_0@ (** @since 4.08.0: val compare : ok:('a -> 'a -> int) -> error:('e -> 'e -> int) -> ('a, 'e) result -> ('a, 'e) result -> int *) @BEGIN_FROM_4_08_0@ val to_option : ('a, 'e) result -> 'a option @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val to_option : ('a, 'e) Stdcompat__pervasives.result -> 'a option @END_BEFORE_4_08_0@ (** @since 4.08.0: val to_option : ('a, 'e) result -> 'a option *) @BEGIN_FROM_4_08_0@ val to_list : ('a, 'e) result -> 'a list @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val to_list : ('a, 'e) Stdcompat__pervasives.result -> 'a list @END_BEFORE_4_08_0@ (** @since 4.08.0: val to_list : ('a, 'e) result -> 'a list *) @BEGIN_FROM_4_08_0@ val to_seq : ('a, 'e) result -> 'a Seq.t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ val to_seq : ('a, 'e) Stdcompat__pervasives.result -> 'a Stdcompat__seq.t @END_BEFORE_4_08_0@ (** @since 4.08.0: val to_seq : ('a, 'e) result -> 'a Seq.t *) end ocaml-stdcompat-20~git20240529/stdcompat__root.ml.in000066400000000000000000000001211463722102200222460ustar00rootroot00000000000000type bytes = Stdcompat__init.bytes type floatarray = Stdcompat__init.floatarray ocaml-stdcompat-20~git20240529/stdcompat__root.mli.in000066400000000000000000000002501463722102200224220ustar00rootroot00000000000000type bytes = Stdcompat__init.bytes (** @before 4.02.0 alias to [string]. *) type floatarray = Stdcompat__init.floatarray (** @before 4.06.0 alias to [float array]. *) ocaml-stdcompat-20~git20240529/stdcompat__seq.ml.in000066400000000000000000000250661463722102200220720ustar00rootroot00000000000000@BEGIN_FROM_4_07_0@ include Seq @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ @BEGIN_WITH_SEQ_PKG@ include Seq @END_WITH_SEQ_PKG@ @BEGIN_WITHOUT_SEQ_PKG@ type 'a t = unit -> 'a node and 'a node = 'a Stdcompat__init.seq_node = | Nil | Cons of 'a * 'a t let empty () = Nil let return x () = Cons (x, empty) let rec map f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> Cons (f x, map f next) let rec filter_map f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> match f x with | None -> filter_map f next () | Some y -> Cons (y, filter_map f next) let rec filter f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> if f x then Cons (x, filter f next) else filter f next () let rec flat_map f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> flat_map_app f (f x) next () and flat_map_app f seq tail () = match seq () with | Nil -> flat_map f tail () | Cons (x, next) -> Cons (x, flat_map_app f next tail) let fold_left f acc seq = let rec aux f acc seq = match seq () with | Nil -> acc | Cons (x, next) -> let acc = f acc x in aux f acc next in aux f acc seq let iter f seq = let rec aux seq = match seq () with | Nil -> () | Cons (x, next) -> f x; aux next in aux seq @END_WITHOUT_SEQ_PKG@ @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_11_0@ let cons x seq () = Cons (x, seq) let rec append a b () = match a () with | Nil -> b () | Cons (hd, tl) -> Cons (hd, append tl b) let rec unfold f state () = match f state with | None -> Nil | Some (value, state) -> Cons (value, unfold f state) @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_13_0@ let concat_map = flat_map let rec concat seq () = match seq () with | Nil -> Nil | Cons (hd, tl) -> append hd (concat tl) () @END_BEFORE_4_13_0@ @BEGIN_FROM_4_14_0@ (* Temporary reimplemented here for compatibility with alpha releases. *) let fold_lefti f acc seq = let rec aux f acc i seq = match seq () with | Nil -> acc | Cons (x, next) -> let acc = f acc i x in aux f acc (succ i) next in aux f acc 0 seq @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ let is_empty seq = match seq () with | Nil -> true | Cons _ -> false let uncons seq = match seq () with | Nil -> None | Cons (hd, tl) -> Some (hd, tl) let rec length_rec accu seq = match seq () with | Nil -> accu | Cons (_hd, tl) -> length_rec (succ accu) tl let length seq = length_rec 0 seq let iteri f seq = let rec aux i seq = match seq () with | Nil -> () | Cons (x, next) -> f i x; aux (succ i) next in aux 0 seq let fold_lefti f acc seq = let rec aux f acc i seq = match seq () with | Nil -> acc | Cons (x, next) -> let acc = f acc i x in aux f acc (succ i) next in aux f acc 0 seq let rec for_all p seq = match seq () with | Nil -> true | Cons (hd, tl) -> p hd && for_all p tl let rec exists p seq = match seq () with | Nil -> false | Cons (hd, tl) -> p hd || exists p tl let rec find p seq = match seq () with | Nil -> None | Cons (hd, tl) -> if p hd then Some hd else find p tl let rec find_map f seq = match seq () with | Nil -> None | Cons (hd, tl) -> match f hd with | None -> find_map f tl | Some _ as result -> result let iter2 f a b = let rec aux a b = match a () with | Nil -> () | Cons (a_hd, a_tl) -> match b () with | Nil -> () | Cons (b_hd, b_tl) -> f a_hd b_hd; aux a_tl b_tl in aux a b let fold_left2 f acc a b = let rec aux acc a b = match a () with | Nil -> acc | Cons (a_hd, a_tl) -> match b () with | Nil -> acc | Cons (b_hd, b_tl) -> aux (f acc a_hd b_hd) a_tl b_tl in aux acc a b let rec for_all2 p a b = match a () with | Nil -> true | Cons (a_hd, a_tl) -> match b () with | Nil -> true | Cons (b_hd, b_tl) -> p a_hd b_hd && for_all2 p a_tl b_tl let rec exists2 p a b = match a () with | Nil -> false | Cons (a_hd, a_tl) -> match b () with | Nil -> false | Cons (b_hd, b_tl) -> p a_hd b_hd || exists2 p a_tl b_tl let rec equal p a b = match a (), b () with | Nil, Nil -> true | Nil, Cons _ | Cons _, Nil -> false | Cons (a_hd, a_tl), Cons (b_hd, b_tl) -> p a_hd b_hd && equal p a_tl b_tl let rec compare o a b = match a (), b () with | Nil, Nil -> 0 | Nil, Cons _ -> -1 | Cons _, Nil -> 1 | Cons (a_hd, a_tl), Cons (b_hd, b_tl) -> match o a_hd b_hd with | 0 -> compare o a_tl b_tl | result -> result let init n f = let rec aux i () = if i < n then Cons (f i, aux (succ i)) else Nil in if n < 0 then invalid_arg "Seq.init: length should be non-negative"; aux 0 let rec repeat x () = Cons (x, repeat x) let rec forever gen () = Cons (gen (), forever gen) let cycle seq () = match seq () with | Nil -> Nil | Cons (hd, tl) -> let rec aux tl' () = match tl' () with | Nil -> Cons (hd, aux tl) | Cons (hd', tl') -> Cons (hd', aux tl') in Cons (hd, aux tl) let rec iterate1 f x () = let fx = f x in Cons (fx, iterate1 f fx) let iterate f x () = Cons (x, iterate1 f x) let mapi f seq = let rec aux i seq () = match seq () with | Nil -> Nil | Cons (x, next) -> Cons (f i x, aux (succ i) next) in aux 0 seq let scan f acc seq = let rec aux f acc seq () = match seq () with | Nil -> Nil | Cons (x, next) -> let acc = f acc x in Cons (acc, aux f acc next) in cons acc (aux f acc seq) let rec take_rec n seq = if n > 0 then fun () -> match seq () with | Nil -> Nil | Cons (hd, tl) -> Cons (hd, take_rec (pred n) tl) else empty let take n seq = if n < 0 then invalid_arg "Seq.take: length should be non-negative"; take_rec n seq let rec drop_rec n seq = match seq () with | Nil -> empty | Cons (_hd, tl) -> let n' = pred n in if n' > 0 then drop_rec n' tl else tl let drop n seq = if n < 0 then invalid_arg "Seq.drop: length should be non-negative"; if n = 0 then seq else drop_rec n seq let rec take_while p seq () = match seq () with | Nil -> Nil | Cons (hd, tl) -> if p hd then Cons (hd, take_while p tl) else Nil let rec drop_while_rec p seq = match seq () with | Nil -> Nil | Cons (hd, tl) as result -> if p hd then drop_while_rec p tl else result let drop_while p seq () = drop_while_rec p seq let rec group eq seq () = match seq () with | Nil -> Nil | Cons (hd, tl) -> Cons (cons hd (take_while (eq hd) tl), group eq (drop_while (eq hd) tl)) let rec memoize seq = let next = lazy (match seq () with | Nil -> Nil | Cons (hd, tl) -> Cons (hd, memoize tl)) in fun () -> Lazy.force next exception Forced_twice let rec once seq = let consumed = ref false in fun () -> if !consumed then raise Forced_twice; consumed := true; match seq () with | Nil -> Nil | Cons (hd, tl) -> Cons (hd, once tl) let rec transpose seq () = match seq () with | Nil -> Nil | Cons (hd, tl) -> let first () = let hd_opt seq = match seq () with | Nil -> None | Cons (hd, _tl) -> Some hd in let tl' = filter_map hd_opt tl in match hd () with | Nil -> tl' () | Cons (hd, _tl) -> Cons (hd, tl') in let others () = let tl_opt seq = match seq () with | Nil -> None | Cons (_hd, tl) -> Some tl in let tl' = filter_map tl_opt tl in match hd () with | Nil -> tl' () | Cons (_hd, tl) -> Cons (tl, tl') in if is_empty first then Nil else Cons (first, transpose others) let rec zip a b () = match a () with | Nil -> Nil | Cons (a_hd, a_tl) -> match b () with | Nil -> Nil | Cons (b_hd, b_tl) -> Cons ((a_hd, b_hd), zip a_tl b_tl) let rec map2 f a b () = match a () with | Nil -> Nil | Cons (a_hd, a_tl) -> match b () with | Nil -> Nil | Cons (b_hd, b_tl) -> Cons (f a_hd b_hd, map2 f a_tl b_tl) let rec interleave a b () = match a () with | Nil -> b () | Cons (hd, tl) -> Cons (hd, interleave b tl) let rec sorted_merge1l o a_cell a_hd a_tl b () = match b () with | Nil -> a_cell | Cons (b_hd, b_tl) as b_cell -> sorted_merge1 o a_cell a_hd a_tl b_cell b_hd b_tl and sorted_merge1r o a b_cell b_hd b_tl () = match a () with | Nil -> b_cell | Cons (a_hd, a_tl) as a_cell -> sorted_merge1 o a_cell a_hd a_tl b_cell b_hd b_tl and sorted_merge1 o a_cell a_hd a_tl b_cell b_hd b_tl = if o a_hd b_hd <= 0 then Cons (a_hd, sorted_merge1r o a_tl b_cell b_hd b_tl) else Cons (b_hd, sorted_merge1l o a_cell a_hd a_tl b_tl) let sorted_merge o a b () = match a (), b () with | Nil, Nil -> Nil | Nil, c | c, Nil -> c | Cons (a_hd, a_tl) as a_cell, (Cons (b_hd, b_tl) as b_cell) -> sorted_merge1 o a_cell a_hd a_tl b_cell b_hd b_tl let rec map_product1 f a_hd a_tl b = match b () with | Nil -> Nil | Cons (b_hd, b_tl) -> Cons (f a_hd b_hd, append (map (fun ai -> f ai b_hd) a_tl) (fun () -> map_product1 f a_hd a_tl b_tl)) let map_product f a b () = match a () with | Nil -> Nil | Cons (a_hd, a_tl) -> map_product1 f a_hd a_tl b let product a b = map_product (fun a b -> (a, b)) a b let unzip seq = (map fst seq, map snd seq) let split = unzip let partition_map f seq = filter_map (fun x -> Stdcompat__either.find_left (f x)) seq, filter_map (fun x -> Stdcompat__either.find_right (f x)) seq let partition p seq = filter p seq, filter (fun x -> not (p x)) seq let rec of_dispenser f () = match f () with | None -> Nil | Some item -> Cons (item, of_dispenser f) let to_dispenser seq = let seq_ref = ref seq in fun () -> match !seq_ref () with | Nil -> None | Cons (hd, tl) -> seq_ref := tl; Some hd let rec ints i () = Cons (i, ints (succ i)) @END_BEFORE_4_14_0@ @BEGIN_BEFORE_5_1_0@ let rec find_index_from index p seq = match seq () with | Nil -> None | Cons (hd, tl) -> if p hd then Some index else find_index_from (succ index) p tl let find_index p seq = find_index_from 0 p seq let rec find_mapi_from index f seq = match seq () with | Nil -> None | Cons (hd, tl) -> match f index hd with | None -> find_mapi_from (succ index) f tl | some -> some let find_mapi f seq = find_mapi_from 0 f seq @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__seq.mli.in000066400000000000000000000000331463722102200222260ustar00rootroot00000000000000include Stdcompat__seq_s.S ocaml-stdcompat-20~git20240529/stdcompat__seq_s.mli.in000066400000000000000000000177201463722102200225630ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_07_0@ type 'a t = unit -> 'a node and 'a node = 'a Stdcompat__init.seq_node = | Nil | Cons of 'a * 'a t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ type 'a t = unit -> 'a node and 'a node = 'a Stdcompat__init.seq_node = | Nil | Cons of 'a * 'a t @END_BEFORE_4_07_0@ (** @since 4.07.0: type 'a t = unit -> 'a node and 'a node = | Nil | Cons of 'a * 'a t *) exception Forced_twice (** Alias for {!Seq.Forced_twice} *) val find_index : ('a -> bool) -> 'a t -> int option (** @since 5.1.0: val find_index : ('a -> bool) -> 'a t -> int option *) val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option (** @since 5.1.0: val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option *) @BEGIN_FROM_5_1_0@ val fold_lefti : ('acc -> int -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_5_0_0@ val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ val fold_lefti : ('acc -> int -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_BEFORE_5_0_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_lefti : ('acc -> int -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @since 5.0.0: val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b *) val is_empty : 'a t -> bool (** @since 4.14.0: val is_empty : 'a t -> bool *) val uncons : 'a t -> ('a * 'a t) option (** @since 4.14.0: val uncons : 'a t -> ('a * 'a t) option *) val length : 'a t -> int (** @since 4.14.0: val length : 'a t -> int *) val iteri : (int -> 'a -> unit) -> 'a t -> unit (** @since 4.14.0: val iteri : (int -> 'a -> unit) -> 'a t -> unit *) val for_all : ('a -> bool) -> 'a t -> bool (** @since 4.14.0: val for_all : ('a -> bool) -> 'a t -> bool *) val exists : ('a -> bool) -> 'a t -> bool (** @since 4.14.0: val exists : ('a -> bool) -> 'a t -> bool *) val find : ('a -> bool) -> 'a t -> 'a option (** @since 4.14.0: val find : ('a -> bool) -> 'a t -> 'a option *) val find_map : ('a -> 'b option) -> 'a t -> 'b option (** @since 4.14.0: val find_map : ('a -> 'b option) -> 'a t -> 'b option *) val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit (** @since 4.14.0: val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit *) @BEGIN_FROM_5_1_0@ val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_14_0@ val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc @END_BEFORE_4_14_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc @since 4.14.0: val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a *) val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool (** @since 4.14.0: val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool *) val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool (** @since 4.14.0: val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool *) val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool (** @since 4.14.0: val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool *) val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int (** @since 4.14.0: val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int *) val init : int -> (int -> 'a) -> 'a t (** @since 4.14.0: val init : int -> (int -> 'a) -> 'a t *) val repeat : 'a -> 'a t (** @since 4.14.0: val repeat : 'a -> 'a t *) val forever : (unit -> 'a) -> 'a t (** @since 4.14.0: val forever : (unit -> 'a) -> 'a t *) val cycle : 'a t -> 'a t (** @since 4.14.0: val cycle : 'a t -> 'a t *) val iterate : ('a -> 'a) -> 'a -> 'a t (** @since 4.14.0: val iterate : ('a -> 'a) -> 'a -> 'a t *) val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t (** @since 4.14.0: val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t *) val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t (** @since 4.14.0: val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t *) val take : int -> 'a t -> 'a t (** @since 4.14.0: val take : int -> 'a t -> 'a t *) val drop : int -> 'a t -> 'a t (** @since 4.14.0: val drop : int -> 'a t -> 'a t *) val take_while : ('a -> bool) -> 'a t -> 'a t (** @since 4.14.0: val take_while : ('a -> bool) -> 'a t -> 'a t *) val drop_while : ('a -> bool) -> 'a t -> 'a t (** @since 4.14.0: val drop_while : ('a -> bool) -> 'a t -> 'a t *) val group : ('a -> 'a -> bool) -> 'a t -> 'a t t (** @since 4.14.0: val group : ('a -> 'a -> bool) -> 'a t -> 'a t t *) val memoize : 'a t -> 'a t (** @since 4.14.0: val memoize : 'a t -> 'a t *) val once : 'a t -> 'a t (** @since 4.14.0: val once : 'a t -> 'a t *) val transpose : 'a t t -> 'a t t (** @since 4.14.0: val transpose : 'a t t -> 'a t t *) val zip : 'a t -> 'b t -> ('a * 'b) t (** @since 4.14.0: val zip : 'a t -> 'b t -> ('a * 'b) t *) val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t (** @since 4.14.0: val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t *) val interleave : 'a t -> 'a t -> 'a t (** @since 4.14.0: val interleave : 'a t -> 'a t -> 'a t *) val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t (** @since 4.14.0: val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t *) val product : 'a t -> 'b t -> ('a * 'b) t (** @since 4.14.0: val product : 'a t -> 'b t -> ('a * 'b) t *) val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t (** @since 4.14.0: val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t *) val unzip : ('a * 'b) t -> ('a t * 'b t) (** @since 4.14.0: val unzip : ('a * 'b) t -> ('a t * 'b t) *) val split : ('a * 'b) t -> ('a t * 'b t) (** @since 4.14.0: val split : ('a * 'b) t -> ('a t * 'b t) *) @BEGIN_FROM_4_14_0@ val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> ('b t * 'c t) @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val partition_map : ('a -> ('b, 'c) Stdcompat__either.t) -> 'a t -> ('b t * 'c t) @END_BEFORE_4_14_0@ (** @since 4.14.0: val partition_map : ('a -> ('b, 'c) Either.t) -> 'a t -> ('b t * 'c t) *) val partition : ('a -> bool) -> 'a t -> ('a t * 'a t) (** @since 4.14.0: val partition : ('a -> bool) -> 'a t -> ('a t * 'a t) *) val of_dispenser : (unit -> 'a option) -> 'a t (** @since 4.14.0: val of_dispenser : (unit -> 'a option) -> 'a t *) val to_dispenser : 'a t -> unit -> 'a option (** @since 4.14.0: val to_dispenser : 'a t -> unit -> 'a option *) val ints : int -> int t (** @since 4.14.0: val ints : int -> int t *) val concat : 'a t t -> 'a t (** @since 4.13.0: val concat : 'a t t -> 'a t *) val concat_map : ('a -> 'b t) -> 'a t -> 'b t (** @since 4.13.0: val concat_map : ('a -> 'b t) -> 'a t -> 'b t *) val cons : 'a -> 'a t -> 'a t (** @since 4.11.0: val cons : 'a -> 'a t -> 'a t *) val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t (** @since 4.11.0: val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t *) val append : 'a t -> 'a t -> 'a t (** @since 4.11.0: val append : 'a t -> 'a t -> 'a t *) val iter : ('a -> unit) -> 'a t -> unit (** @since 4.07.0: val iter : ('a -> unit) -> 'a t -> unit *) @BEGIN_FROM_5_1_0@ val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_07_0@ val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_BEFORE_4_07_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @since 4.07.0: val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a *) val empty : 'a t (** @since 4.07.0: val empty : 'a t *) val return : 'a -> 'a t (** @since 4.07.0: val return : 'a -> 'a t *) val map : ('a -> 'b) -> 'a t -> 'b t (** @since 4.07.0: val map : ('a -> 'b) -> 'a t -> 'b t *) val filter : ('a -> bool) -> 'a t -> 'a t (** @since 4.07.0: val filter : ('a -> bool) -> 'a t -> 'a t *) val filter_map : ('a -> 'b option) -> 'a t -> 'b t (** @since 4.07.0: val filter_map : ('a -> 'b option) -> 'a t -> 'b t *) val flat_map : ('a -> 'b t) -> 'a t -> 'b t (** @since 4.07.0: val flat_map : ('a -> 'b t) -> 'a t -> 'b t *) end ocaml-stdcompat-20~git20240529/stdcompat__set.ml.in000066400000000000000000000365731463722102200221020ustar00rootroot00000000000000module type OrderedType = Set.OrderedType module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end @BEGIN_FROM_5_1_0@ module Make = Set.Make @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Make (Ord : OrderedType) = struct include Set.Make (Ord) @BEGIN_WITH_MAGIC@ @BEGIN_BEFORE_4_12_0@ type internal = Empty | Node of internal * elt * internal * int @BEGIN_FROM_4_02_0@ [@@ocaml.warning "-37"] @END_FROM_4_02_0@ @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_11_0@ external t_of_internal : internal -> t = "%identity" @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_12_0@ external internal_of_t : t -> internal = "%identity" @END_BEFORE_4_12_0@ @END_WITH_MAGIC@ @BEGIN_BEFORE_4_12_0@ @BEGIN_WITH_MAGIC@ type enumeration = End | More of elt * internal * enumeration let rec snoc_enum s e = match s with Empty -> e | Node (l, v, r, _h) -> snoc_enum r (More(v, l, e)) let rec rev_seq_of_enum_ c () = match c with | End -> Stdcompat__seq.Nil | More (x, t, rest) -> Stdcompat__seq.Cons (x, rev_seq_of_enum_ (snoc_enum t rest)) let to_rev_seq (s : t) = let s = internal_of_t s in rev_seq_of_enum_ (snoc_enum s End) @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_rev_seq s = Stdcompat__list.to_seq (List.rev (elements s)) @END_WITHOUT_MAGIC@ @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_02_0@ let of_list l = List.fold_left (fun s item -> add item s) empty l @END_BEFORE_4_02_0@ @BEGIN_BEFORE_3_08_0@ @BEGIN_WITH_MAGIC@ let rec iter f = function | Empty -> () | Node (l, v, r, _) as t -> iter f l; f v; iter f r let iter (f : elt -> unit) (s : t) : unit = iter f (internal_of_t s) let rec fold f s a = match s with | Empty -> a | Node (l, v, r, _) as t -> let a = fold f l a in let a = f v a in fold f r a let fold (f : elt -> 'a -> 'a) (s : t) (a : 'a) : 'a = fold f (internal_of_t s) a @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let iter f s = List.iter f (elements s) let fold f s a = List.fold_left (fun a item -> f item a) a (elements s) @END_WITHOUT_MAGIC@ @END_BEFORE_3_08_0@ @BEGIN_BEFORE_4_11_0@ @BEGIN_WITH_MAGIC@ let height = function | Empty -> 0 | Node (_, _, _, h) -> h let create l v r = let hl = height l in let hr = height r in Node (l, v, r, (if hl >= hr then hl + 1 else hr + 1)) let bal l v r = let hl = match l with Empty -> 0 | Node (_, _, _, h) -> h in let hr = match r with Empty -> 0 | Node (_, _, _, h) -> h in if hl > hr + 2 then begin match l with Empty -> invalid_arg "Set.bal" | Node (ll, lv, lr, _) -> if height ll >= height lr then create ll lv (create lr v r) else begin match lr with Empty -> invalid_arg "Set.bal" | Node (lrl, lrv, lrr, _) -> create (create ll lv lrl) lrv (create lrr v r) end end else if hr > hl + 2 then begin match r with Empty -> invalid_arg "Set.bal" | Node (rl, rv, rr, _) -> if height rr >= height rl then create (create l v rl) rv rr else begin match rl with Empty -> invalid_arg "Set.bal" | Node (rll, rlv, rlr, _) -> create (create l v rll) rlv (create rlr rv rr) end end else Node (l, v, r, (if hl >= hr then hl + 1 else hr + 1)) let rec add_min_element x = function | Empty -> internal_of_t (singleton x) | Node (l, v, r, _) -> bal (add_min_element x l) v r let rec add_max_element x = function | Empty -> internal_of_t (singleton x) | Node (l, v, r, _) -> bal l v (add_max_element x r) let rec join l v r = match (l, r) with (Empty, _) -> add_min_element v r | (_, Empty) -> add_max_element v l | (Node (ll, lv, lr, lh), Node (rl, rv, rr, rh)) -> if lh > rh + 2 then bal ll lv (join lr v r) else if rh > lh + 2 then bal (join l v rl) rv rr else create l v r let try_join l v r = if (l = Empty || Ord.compare (max_elt (t_of_internal l)) v < 0) && (r = Empty || Ord.compare v (min_elt (t_of_internal r)) < 0) then join l v r else internal_of_t (union (t_of_internal l) (add v (t_of_internal r))) let rec remove_min_elt = function | Empty -> invalid_arg "Set.remove_min_elt" | Node (Empty, _, r, _) -> r | Node (l, v, r, _) -> bal (remove_min_elt l) v r let try_concat t1 t2 = match (t1, t2) with | (Empty, t) -> t | (t, Empty) -> t | (_, _) -> try_join t1 (min_elt (t_of_internal t2)) (remove_min_elt t2) let rec filter_map f = function | Empty -> Empty | Node (l, v, r, _) as t -> (* enforce left-to-right evaluation order *) let l' = filter_map f l in let v' = f v in let r' = filter_map f r in begin match v' with | Some v' -> if l == l' && v == v' && r == r' then t else try_join l' v' r' | None -> try_concat l' r' end let filter_map (f : elt -> elt option) (s : t) : t = t_of_internal (filter_map f (internal_of_t s)) @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ type map_changed = | Changed of t | Unchanged of elt list let filter_map f s = match fold (fun item accu -> match accu, f item with | Changed set, None -> Changed set | Changed set, Some item' -> Changed (add item' set) | Unchanged list, None -> Changed (of_list list) | Unchanged list, Some item' -> if item == item' then Unchanged (item :: list) else Changed (add item' (of_list list))) s (Unchanged []) with | Changed s -> s | Unchanged _ -> s @END_WITHOUT_MAGIC@ @END_BEFORE_4_11_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_WITH_MAGIC@ type split_bis = | Found | NotFound of internal * (unit -> internal) let rec split_bis x = function | Empty -> NotFound (Empty, (fun () -> Empty)) | Node (l, v, r, _) -> let c = Ord.compare x v in if c = 0 then Found else if c < 0 then match split_bis x l with | Found -> Found | NotFound (ll, rl) -> NotFound (ll, (fun () -> join (rl ()) v r)) else match split_bis x r with | Found -> Found | NotFound (lr, rr) -> NotFound (join l v lr, rr) let rec disjoint s1 s2 = match (s1, s2) with (Empty, _) | (_, Empty) -> true | (Node (l1, v1, r1, _), t2) -> if s1 == s2 then false else match split_bis v1 t2 with NotFound(l2, r2) -> disjoint l1 l2 && disjoint r1 (r2 ()) | Found -> false let disjoint (s1 : t) (s2 : t) : bool = disjoint (internal_of_t s1) (internal_of_t s2) @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let disjoint s s' = is_empty (inter s s') @END_WITHOUT_MAGIC@ @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_07_0@ let add_seq i m = Stdcompat__seq.fold_left (fun s x -> add x s) m i let of_seq i = add_seq i empty @BEGIN_WITH_MAGIC@ let rec cons_enum s e = match s with Empty -> e | Node (l, v, r, _h) -> cons_enum l (More(v, r, e)) let rec seq_of_enum_ c () = match c with | End -> Stdcompat__seq.Nil | More (x, t, rest) -> Stdcompat__seq.Cons (x, seq_of_enum_ (cons_enum t rest)) let to_seq (s : t) = let s : internal = internal_of_t s in seq_of_enum_ (cons_enum s End) let to_seq_from low s = let s : internal = internal_of_t s in let rec aux low s c = match s with | Empty -> c | Node (l, v, r, _h) -> begin match Ord.compare v low with | 0 -> More (v, r, c) | n when n<0 -> aux low r c | _ -> aux low l (More (v, r, c)) end in seq_of_enum_ (aux low s End) @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_seq s = Stdcompat__list.to_seq (elements s) let elements_from low s = let rec cut l = match l with | [] -> [] | hd :: tl -> if Ord.compare low hd < 0 then cut tl else l in cut (elements s) let to_seq_from low s = Stdcompat__list.to_seq (elements_from low s) @END_WITHOUT_MAGIC@ @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_01_0@ exception Find of elt @BEGIN_WITH_MAGIC@ let rec find_internal x = function Empty -> raise Not_found | Node (l, v, r, _h) -> let c = Ord.compare x v in if c = 0 then v else find_internal x (if c < 0 then l else r) let find x (s : t) = let s : internal = internal_of_t s in find_internal x s @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let find x s = try iter (fun y -> if Ord.compare x y = 0 then raise (Find y)) s; raise Not_found with Find y -> y @END_WITHOUT_MAGIC@ @END_BEFORE_4_01_0@ @BEGIN_BEFORE_4_05_0@ let min_elt_opt s = Stdcompat__tools.option_find min_elt s let max_elt_opt s = Stdcompat__tools.option_find max_elt s let choose_opt s = Stdcompat__tools.option_find choose s @BEGIN_WITH_MAGIC@ let rec find_first_aux v0 f = function Empty -> v0 | Node (l, v, r, _h) -> if f v then find_first_aux v f l else find_first_aux v0 f r let rec find_first_internal f = function Empty -> raise Not_found | Node (l, v, r, _h) -> if f v then find_first_aux v f l else find_first_internal f r let find_first f (s : t) = let s : internal = internal_of_t s in find_first_internal f s let rec find_first_opt_aux v0 f = function Empty -> Some v0 | Node (l, v, r, _h) -> if f v then find_first_opt_aux v f l else find_first_opt_aux v0 f r let rec find_first_opt_internal f = function Empty -> None | Node (l, v, r, _h) -> if f v then find_first_opt_aux v f l else find_first_opt_internal f r let find_first_opt f (s : t) = let s : internal = internal_of_t s in find_first_opt_internal f s let rec find_last_aux v0 f = function Empty -> v0 | Node (l, v, r, _h) -> if f v then find_last_aux v f r else find_last_aux v0 f l let rec find_last_internal f = function Empty -> raise Not_found | Node (l, v, r, _h) -> if f v then find_last_aux v f r else find_last_internal f l let find_last f (s : t) = let s : internal = internal_of_t s in find_last_internal f s let rec find_last_opt_aux v0 f = function Empty -> Some v0 | Node (l, v, r, _h) -> if f v then find_last_opt_aux v f r else find_last_opt_aux v0 f l let rec find_last_opt_internal f = function Empty -> None | Node (l, v, r, _h) -> if f v then find_last_opt_aux v f r else find_last_opt_internal f l let find_last_opt f (s : t) = let s : internal = internal_of_t s in find_last_opt_internal f s let rec find_opt_internal x = function Empty -> None | Node (l, v, r, _h) -> let c = Ord.compare x v in if c = 0 then Some v else find_opt_internal x (if c < 0 then l else r) let find_opt f (s : t) = let s : internal = internal_of_t s in find_opt_internal f s @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let find_opt x s = Stdcompat__tools.option_find (find x) s exception Find of elt let find_first_opt p s = try iter (fun x -> if p x then raise (Find x)) s; None with Find x -> Some x let find_first p s = try iter (fun x -> if p x then raise (Find x)) s; raise Not_found with Find x -> x exception Local_not_found let find_last_opt p s = let last = ref None in try iter (fun x -> if p x then last := Some x else match !last with | None -> raise Local_not_found | Some x -> raise (Find x)) s; !last with | Local_not_found -> None | Find x -> !last let find_last p s = match find_last_opt p s with | None -> raise Not_found | Some x -> x @END_WITHOUT_MAGIC@ @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_WITH_MAGIC@ let rec map f = function | Empty -> Empty | Node (l, v, r, _) as t -> (* enforce left-to-right evaluation order *) let l' = map f l in let v' = f v in let r' = map f r in if l == l' && v == v' && r == r' then t else try_join l' v' r' let map f s = (t_of_internal (map f (internal_of_t s : internal)) : t) @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let map f s = match fold (fun item accu -> let item' = f item in match accu with | Changed set -> Changed (add item' set) | Unchanged list -> if item == item' then Unchanged (item :: list) else Changed (add item' (of_list list))) s (Unchanged []) with | Changed s -> s | Unchanged _ -> s @END_WITHOUT_MAGIC@ @END_BEFORE_4_04_0@ @BEGIN_BEFORE_3_08_0@ let split x s = let add item (passed, (l, present, r)) = if passed then (passed, (l, present, add item r)) else let o = Ord.compare item x in if o < 0 then (passed, (add item l, present, add item r)) else if o > 0 then (true, (l, false, add item r)) else (true, (l, true, r)) in snd (fold add s (false, (empty, false, empty))) @END_BEFORE_3_08_0@ @BEGIN_BEFORE_5_1_0@ let to_list s = elements s @END_BEFORE_5_1_0@ end @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__set.mli.in000066400000000000000000000000331463722102200222310ustar00rootroot00000000000000include Stdcompat__set_s.S ocaml-stdcompat-20~git20240529/stdcompat__set_s.mli.in000066400000000000000000000150141463722102200225600ustar00rootroot00000000000000module type S = sig module type OrderedType = sig type t val compare : t -> t -> int end (** Alias for {!Set.OrderedType} *) @BEGIN_FROM_5_1_0@ module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Stdcompat__seq.t val to_seq : t -> elt Stdcompat__seq.t val to_rev_seq : t -> elt Stdcompat__seq.t val add_seq : elt Stdcompat__seq.t -> t -> t val of_seq : elt Stdcompat__seq.t -> t end @END_BEFORE_5_1_0@ (** @since 5.1.0: module type S = sig type elt type t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Seq.t val to_seq : t -> elt Seq.t val to_rev_seq : t -> elt Seq.t val add_seq : elt Seq.t -> t -> t val of_seq : elt Seq.t -> t end *) @BEGIN_FROM_5_1_0@ module Make = Set.Make @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ module Make : functor (Ord : OrderedType) -> sig type elt = Ord.t type t = Set.Make(Ord).t val empty : t val add : elt -> t -> t val singleton : elt -> t val remove : elt -> t -> t val union : t -> t -> t val inter : t -> t -> t val disjoint : t -> t -> bool val diff : t -> t -> t val cardinal : t -> int val elements : t -> elt list val min_elt : t -> elt val min_elt_opt : t -> elt option val max_elt : t -> elt val max_elt_opt : t -> elt option val choose : t -> elt val choose_opt : t -> elt option val find : elt -> t -> elt val find_opt : elt -> t -> elt option val find_first : (elt -> bool) -> t -> elt val find_first_opt : (elt -> bool) -> t -> elt option val find_last : (elt -> bool) -> t -> elt val find_last_opt : (elt -> bool) -> t -> elt option val iter : (elt -> unit) -> t -> unit val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc val map : (elt -> elt) -> t -> t val filter : (elt -> bool) -> t -> t val filter_map : (elt -> elt option) -> t -> t val partition : (elt -> bool) -> t -> (t * t) val split : elt -> t -> (t * bool * t) val is_empty : t -> bool val mem : elt -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val subset : t -> t -> bool val for_all : (elt -> bool) -> t -> bool val exists : (elt -> bool) -> t -> bool val to_list : t -> elt list val of_list : elt list -> t val to_seq_from : elt -> t -> elt Stdcompat__seq.t val to_seq : t -> elt Stdcompat__seq.t val to_rev_seq : t -> elt Stdcompat__seq.t val add_seq : elt Stdcompat__seq.t -> t -> t val of_seq : elt Stdcompat__seq.t -> t end @END_BEFORE_5_1_0@ (** @since 5.1.0: module Make = Set.Make *) end ocaml-stdcompat-20~git20240529/stdcompat__stack.ml.in000066400000000000000000000026331463722102200224020ustar00rootroot00000000000000include Stack @BEGIN_BEFORE_4_08_0@ @BEGIN_WITH_MAGIC@ type 'a internal = { mutable c : 'a list; mutable len : int; } let pop_opt (s : 'a t) = let s : 'a internal = Obj.magic s in match s.c with | [] -> None | hd :: tl -> s.c <- tl; s.len <- pred s.len; Some hd let top_opt (s : 'a t) = let s : 'a internal = Obj.magic s in match s.c with | [] -> None | hd :: _tl -> Some hd @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let pop_opt s = try Some (pop s) with Empty -> None let top_opt s = try Some (top s) with Empty -> None @END_WITHOUT_MAGIC@ @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_MAGIC@ let fold f acc (s : 'a t) = let s : 'a internal = Obj.magic s in List.fold_left f acc s.c @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let fold f acc s = let r = ref acc in iter (fun item -> r := f !r item) s; !r @END_WITHOUT_MAGIC@ @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_07_0@ let add_seq s i = Stdcompat__seq.iter (fun x -> push x s) i let of_seq g = let s = create() in add_seq s g; s @BEGIN_WITH_MAGIC@ let to_seq (s : 'a t) = let s : 'a internal = Obj.magic s in Stdcompat__list.to_seq s.c @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ let to_list s = fold (fun accu content -> content :: accu) [] s let to_seq s = Stdcompat__list.to_seq (List.rev (to_list s)) @END_WITHOUT_MAGIC@ @END_BEFORE_4_07_0@ @BEGIN_BEFORE_5_1_0@ let drop s = ignore (pop s) @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__stack.mli.in000066400000000000000000000000351463722102200225450ustar00rootroot00000000000000include Stdcompat__stack_s.S ocaml-stdcompat-20~git20240529/stdcompat__stack_s.mli.in000066400000000000000000000063031463722102200230730ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_5_1_0@ @BEGIN_FROM_4_12_0@ type !'a t = 'a Stack.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a Stack.t @END_BEFORE_4_12_0@ @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_5_0_0@ type 'a t @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_4_12_0@ type !'a t = 'a Stack.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a Stack.t @END_BEFORE_4_12_0@ @END_BEFORE_5_0_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: type !'a t @since 3.07.0: type !'a t *) exception Empty (** Alias for {!Stack.Empty} *) val drop : 'a t -> unit (** @since 5.1.0: val drop : 'a t -> unit *) @BEGIN_FROM_5_1_0@ val to_seq : 'a t -> 'a Seq.t @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_5_0_0@ val to_seq : 'a t -> 'a Stdcompat__seq.t @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_4_07_0@ val to_seq : 'a t -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a t -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ @END_BEFORE_5_0_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val to_seq : 'a t -> 'a Seq.t @since 4.07.0: val to_seq : 'a t -> 'a Seq.t *) @BEGIN_FROM_5_1_0@ val add_seq : 'a t -> 'a Seq.t -> unit @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_5_0_0@ val add_seq : 'a t -> 'a Stdcompat__seq.t -> unit @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_4_07_0@ val add_seq : 'a t -> 'a Seq.t -> unit @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val add_seq : 'a t -> 'a Stdcompat__seq.t -> unit @END_BEFORE_4_07_0@ @END_BEFORE_5_0_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val add_seq : 'a t -> 'a Seq.t -> unit @since 4.07.0: val add_seq : 'a t -> 'a Seq.t -> unit *) @BEGIN_FROM_5_1_0@ val of_seq : 'a Seq.t -> 'a t @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_5_0_0@ val of_seq : 'a Stdcompat__seq.t -> 'a t @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a t @END_BEFORE_4_07_0@ @END_BEFORE_5_0_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val of_seq : 'a Seq.t -> 'a t @since 4.07.0: val of_seq : 'a Seq.t -> 'a t *) val pop_opt : 'a t -> 'a option (** @since 4.08.0: val pop_opt : 'a t -> 'a option *) val top_opt : 'a t -> 'a option (** @since 4.08.0: val top_opt : 'a t -> 'a option *) @BEGIN_FROM_5_0_0@ val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ @BEGIN_FROM_4_03_0@ val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @END_BEFORE_4_03_0@ @END_BEFORE_5_0_0@ (** @since 5.1.0: val fold : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc @since 4.03.0: val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b *) val create : unit -> 'a t (** Alias for {!Stack.create} *) val push : 'a -> 'a t -> unit (** Alias for {!Stack.push} *) val pop : 'a t -> 'a (** Alias for {!Stack.pop} *) val top : 'a t -> 'a (** Alias for {!Stack.top} *) val clear : 'a t -> unit (** Alias for {!Stack.clear} *) val copy : 'a t -> 'a t (** Alias for {!Stack.copy} *) val is_empty : 'a t -> bool (** Alias for {!Stack.is_empty} *) val length : 'a t -> int (** Alias for {!Stack.length} *) val iter : ('a -> unit) -> 'a t -> unit (** Alias for {!Stack.iter} *) end ocaml-stdcompat-20~git20240529/stdcompat__stdlib.ml.in000066400000000000000000000053511463722102200225560ustar00rootroot00000000000000@BEGIN_FROM_5_0_0@ include Stdlib @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module Pervasives = Stdcompat__pervasives include Pervasives let acosh x = log (x +. sqrt (x *. x -. 1.0)) let asinh x = log (x +. sqrt (x *. x +. 1.0)) let atanh x = 0.5 *. log ((1.0 +. x) /. (1.0 -. x)) @BEGIN_FROM_4_12_0@ external __FUNCTION__ : string = "%loc_FUNCTION" @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ let __FUNCTION__ = "" @END_BEFORE_4_12_0@ module Arg = Stdcompat__arg module Array = Stdcompat__array module ArrayLabels = Stdcompat__arrayLabels module Atomic = Stdcompat__atomic (* Bigarray is not exported before 4.02.0 to allow programs not to be compiled with this module, this may change in the future. From 4.02.0 and before 4.07.0, Bigarray is effectively available only if the library is linked, but --no-alias-deps allows the alias to be defined here without requiring such a link. *) @BEGIN_FROM_4_02_0@ module Bigarray = Bigarray @END_FROM_4_02_0@ module Bool = Stdcompat__bool module Buffer = Stdcompat__buffer module Bytes = Stdcompat__bytes module BytesLabels = Stdcompat__bytesLabels module Callback = Callback module Char = Stdcompat__char module Complex = Complex module Digest = Stdcompat__digest module Either = Stdcompat__either module Ephemeron = Stdcompat__ephemeron module Filename = Stdcompat__filename module Float = Stdcompat__float module Format = Stdcompat__format module Fun = Stdcompat__fun module Gc = Gc module Genlex = Genlex module Hashtbl = Stdcompat__hashtbl module In_channel = Stdcompat__in_channel module Int = Stdcompat__int module Int32 = Stdcompat__int32 module Int64 = Stdcompat__int64 module Lazy = Stdcompat__lazy module Lexing = Stdcompat__lexing module List = Stdcompat__list module ListLabels = Stdcompat__listLabels module Map = Stdcompat__map module Marshal = Marshal module MoreLabels = MoreLabels module Nativeint = Stdcompat__nativeint module Obj = Obj module Oo = Oo module Option = Stdcompat__option module Out_channel = Stdcompat__out_channel module Parsing = Parsing module Printexc = Stdcompat__printexc module Printf = Stdcompat__printf module Queue = Stdcompat__queue module Random = Stdcompat__random module Result = Stdcompat__result module Scanf = Scanf module Seq = Stdcompat__seq module Set = Stdcompat__set module Stack = Stdcompat__stack module StdLabels = struct module Array = Stdcompat__arrayLabels module Bytes = Stdcompat__bytesLabels module List = Stdcompat__listLabels module String = Stdcompat__stringLabels end module String = Stdcompat__string module StringLabels = Stdcompat__stringLabels module Sys = Stdcompat__sys module Uchar = Stdcompat__uchar module Unit = Stdcompat__unit module Weak = Stdcompat__weak @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__stdlib.mli.in000066400000000000000000000000361463722102200227220ustar00rootroot00000000000000include Stdcompat__stdlib_s.S ocaml-stdcompat-20~git20240529/stdcompat__stdlib_s.mli.in000066400000000000000000000066131463722102200232530ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_5_0_0@ include module type of struct include Stdlib end @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module Pervasives : Stdcompat__pervasives_s.S include Stdcompat__pervasives_s.S val acosh : float -> float val asinh : float -> float val atanh : float -> float module Arg : Stdcompat__arg_s.S module Array : Stdcompat__array_s.S module ArrayLabels : Stdcompat__arrayLabels_s.S module Atomic : Stdcompat__atomic_s.S (* Bigarray is not exported before 4.02.0 to allow programs not to be compiled with this module, this may change in the future. From 4.02.0 and before 4.07.0, Bigarray is effectively available only if the library is linked, but --no-alias-deps allows the alias to be defined here without requiring such a link. *) @BEGIN_FROM_4_02_0@ module Bigarray = Bigarray @END_FROM_4_02_0@ module Bool : Stdcompat__bool_s.S module Buffer : Stdcompat__buffer_s.S module Bytes : Stdcompat__bytes_s.S module BytesLabels : Stdcompat__bytesLabels_s.S @BEGIN_FROM_3_12_0@ module Callback : module type of (struct include Callback end) @END_FROM_3_12_0@ module Char : Stdcompat__char_s.S @BEGIN_FROM_3_12_0@ module Complex : module type of (struct include Complex end) @END_FROM_3_12_0@ module Digest : Stdcompat__digest_s.S module Either : Stdcompat__either_s.S module Ephemeron : Stdcompat__ephemeron_s.S module Filename : Stdcompat__filename_s.S module Float : Stdcompat__float_s.S module Format : Stdcompat__format_s.S module Fun : Stdcompat__fun_s.S @BEGIN_FROM_3_12_0@ module Gc : module type of (struct include Gc end) @END_FROM_3_12_0@ module Hashtbl : Stdcompat__hashtbl_s.S module In_channel : Stdcompat__in_channel_s.S module Out_channel : Stdcompat__out_channel_s.S module Int : Stdcompat__int_s.S module Int32 : Stdcompat__int32_s.S module Int64 : Stdcompat__int64_s.S module Lazy : Stdcompat__lazy_s.S module Lexing : Stdcompat__lexing_s.S module List : Stdcompat__list_s.S module ListLabels : Stdcompat__listLabels_s.S module Map : Stdcompat__map_s.S module Nativeint : Stdcompat__nativeint_s.S @BEGIN_FROM_3_12_0@ module Obj : module type of (struct include Obj end) @END_FROM_3_12_0@ @BEGIN_FROM_3_12_0@ module Oo : module type of (struct include Oo end) @END_FROM_3_12_0@ module Option : Stdcompat__option_s.S @BEGIN_FROM_3_12_0@ module Parsing : module type of (struct include Parsing end) @END_FROM_3_12_0@ module Printexc : Stdcompat__printexc_s.S module Printf : Stdcompat__printf_s.S module Queue : Stdcompat__queue_s.S module Random : Stdcompat__random_s.S module Result : Stdcompat__result_s.S @BEGIN_FROM_3_12_0@ module Scanf : module type of (struct include Scanf end) @END_FROM_3_12_0@ module Seq : Stdcompat__seq_s.S module Set : Stdcompat__set_s.S module Stack : Stdcompat__stack_s.S module StdLabels : sig module Array : Stdcompat__arrayLabels_s.S module Bytes : Stdcompat__bytesLabels_s.S module List : Stdcompat__listLabels_s.S module String : Stdcompat__stringLabels_s.S end module String : Stdcompat__string_s.S module StringLabels : Stdcompat__stringLabels_s.S module Sys : Stdcompat__sys_s.S module Uchar : Stdcompat__uchar_s.S module Unit : Stdcompat__unit_s.S module Weak : Stdcompat__weak_s.S @END_BEFORE_5_0_0@ end ocaml-stdcompat-20~git20240529/stdcompat__string.ml.in000066400000000000000000000101351463722102200225770ustar00rootroot00000000000000include String @BEGIN_BEFORE_4_07_0@ let of_seq g = Buffer.contents (Stdcompat__buffer.of_seq g) let to_seq s = Stdcompat__tools.vec_to_seq length unsafe_get s let to_seqi s = Stdcompat__tools.vec_to_seqi length unsafe_get s @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let index_opt s c = Stdcompat__tools.option_find (index s) c let rindex_opt s c = Stdcompat__tools.option_find (rindex s) c let index_from_opt s i c = Stdcompat__tools.option_find (index_from s i) c let rindex_from_opt s i c = Stdcompat__tools.option_find (rindex_from s i) c @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_04_0@ let split_on_char c s = List.map Stdcompat__bytes.unsafe_to_string (Stdcompat__bytes.split_on_char c (Stdcompat__bytes.unsafe_of_string s)) @END_BEFORE_4_04_0@ @BEGIN_BEFORE_4_03_0@ let lowercase_ascii = lowercase let uppercase_ascii = uppercase let capitalize_ascii = capitalize let uncapitalize_ascii = uncapitalize let equal : t -> t -> bool = ( = ) @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_02_0@ let init = Stdcompat__bytes.init let mapi = Stdcompat__bytes.mapi @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_00_0@ let iteri = Stdcompat__bytes.iteri let map = Stdcompat__bytes.map let trim = Stdcompat__bytes.trim @END_BEFORE_4_00_0@ @BEGIN_BEFORE_4_13_0@ let empty = "" let of_bytes = Stdcompat__bytes.to_string let to_bytes = Stdcompat__bytes.of_string let cat = ( ^ ) let starts_with ~prefix s = Stdcompat__bytes.starts_with ~prefix:(Stdcompat__bytes.unsafe_of_string prefix) (Stdcompat__bytes.unsafe_of_string s) let ends_with ~suffix s = Stdcompat__bytes.ends_with ~suffix:(Stdcompat__bytes.unsafe_of_string suffix) (Stdcompat__bytes.unsafe_of_string s) let fold_left f init s = Stdcompat__bytes.fold_left f init (Stdcompat__bytes.unsafe_of_string s) let fold_right f s init = Stdcompat__bytes.fold_right f (Stdcompat__bytes.unsafe_of_string s) init let for_all f s = Stdcompat__bytes.for_all f (Stdcompat__bytes.unsafe_of_string s) let exists f s = Stdcompat__bytes.exists f (Stdcompat__bytes.unsafe_of_string s) let get_uint8 s i = Stdcompat__bytes.get_uint8 (Stdcompat__bytes.unsafe_of_string s) i let get_int8 s i = Stdcompat__bytes.get_int8 (Stdcompat__bytes.unsafe_of_string s) i let get_uint16_ne s i = Stdcompat__bytes.get_uint16_ne (Stdcompat__bytes.unsafe_of_string s) i let get_uint16_be s i = Stdcompat__bytes.get_uint16_be (Stdcompat__bytes.unsafe_of_string s) i let get_uint16_le s i = Stdcompat__bytes.get_uint16_le (Stdcompat__bytes.unsafe_of_string s) i let get_int16_ne s i = Stdcompat__bytes.get_int16_ne (Stdcompat__bytes.unsafe_of_string s) i let get_int16_be s i = Stdcompat__bytes.get_int16_be (Stdcompat__bytes.unsafe_of_string s) i let get_int16_le s i = Stdcompat__bytes.get_int16_le (Stdcompat__bytes.unsafe_of_string s) i let get_int32_ne s i = Stdcompat__bytes.get_int32_ne (Stdcompat__bytes.unsafe_of_string s) i let get_int32_be s i = Stdcompat__bytes.get_int32_be (Stdcompat__bytes.unsafe_of_string s) i let get_int32_le s i = Stdcompat__bytes.get_int32_le (Stdcompat__bytes.unsafe_of_string s) i let get_int64_ne s i = Stdcompat__bytes.get_int64_ne (Stdcompat__bytes.unsafe_of_string s) i let get_int64_be s i = Stdcompat__bytes.get_int64_be (Stdcompat__bytes.unsafe_of_string s) i let get_int64_le s i = Stdcompat__bytes.get_int64_le (Stdcompat__bytes.unsafe_of_string s) i @END_BEFORE_4_13_0@ @BEGIN_BEFORE_4_14_0@ let get_utf_8_uchar s i = Stdcompat__bytes.get_utf_8_uchar (Stdcompat__bytes.unsafe_of_string s) i let is_valid_utf_8 s = Stdcompat__bytes.is_valid_utf_8 (Stdcompat__bytes.unsafe_of_string s) let get_utf_16be_uchar s i = Stdcompat__bytes.get_utf_16be_uchar (Stdcompat__bytes.unsafe_of_string s) i let is_valid_utf_16be s = Stdcompat__bytes.is_valid_utf_16be (Stdcompat__bytes.unsafe_of_string s) let get_utf_16le_uchar s i = Stdcompat__bytes.get_utf_16le_uchar (Stdcompat__bytes.unsafe_of_string s) i let is_valid_utf_16le s = Stdcompat__bytes.is_valid_utf_16le (Stdcompat__bytes.unsafe_of_string s) @END_BEFORE_4_14_0@ @BEGIN_BEFORE_5_0_0@ let seeded_hash = Stdcompat__hashtbl.seeded_hash let hash = Hashtbl.hash @END_BEFORE_5_0_0@ ocaml-stdcompat-20~git20240529/stdcompat__string.mli.in000066400000000000000000000000361463722102200227470ustar00rootroot00000000000000include Stdcompat__string_s.S ocaml-stdcompat-20~git20240529/stdcompat__stringLabels.ml.in000066400000000000000000000000321463722102200237150ustar00rootroot00000000000000include Stdcompat__string ocaml-stdcompat-20~git20240529/stdcompat__stringLabels.mli.in000066400000000000000000000000441463722102200240710ustar00rootroot00000000000000include Stdcompat__stringLabels_s.S ocaml-stdcompat-20~git20240529/stdcompat__stringLabels_s.mli.in000066400000000000000000000241111463722102200244140ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_3_08_0@ type t = string @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ type t = string @END_BEFORE_3_08_0@ (** @since 3.08.0: type t = string *) val hash : t -> int (** @since 5.0.0: val hash : t -> int *) val seeded_hash : int -> t -> int (** @since 5.0.0: val seeded_hash : int -> t -> int *) @BEGIN_FROM_4_14_0@ val get_utf_8_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_8_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_8_uchar : t -> int -> Uchar.utf_decode *) val is_valid_utf_8 : t -> bool (** @since 4.14.0: val is_valid_utf_8 : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16be_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16be_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16be_uchar : t -> int -> Uchar.utf_decode *) val is_valid_utf_16be : t -> bool (** @since 4.14.0: val is_valid_utf_16be : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16le_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16le_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16le_uchar : t -> int -> Uchar.utf_decode *) val is_valid_utf_16le : t -> bool (** @since 4.14.0: val is_valid_utf_16le : t -> bool *) val empty : string (** @since 4.13.0: val empty : string *) @BEGIN_FROM_4_13_0@ val of_bytes : bytes -> string @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val of_bytes : Stdcompat__init.bytes -> string @END_BEFORE_4_13_0@ (** @since 4.13.0: val of_bytes : bytes -> string *) @BEGIN_FROM_4_13_0@ val to_bytes : string -> bytes @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val to_bytes : string -> Stdcompat__init.bytes @END_BEFORE_4_13_0@ (** @since 4.13.0: val to_bytes : string -> bytes *) val cat : string -> string -> string (** @since 4.13.0: val cat : string -> string -> string *) val starts_with : prefix:string -> string -> bool (** @since 4.13.0: val starts_with : prefix:string -> string -> bool *) val ends_with : suffix:string -> string -> bool (** @since 4.13.0: val ends_with : suffix:string -> string -> bool *) @BEGIN_FROM_5_1_0@ val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> string -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_left : f:('a -> char -> 'a) -> init:'a -> string -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> string -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> string -> 'acc @since 4.13.0: val fold_left : f:('a -> char -> 'a) -> init:'a -> string -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : f:(char -> 'acc -> 'acc) -> string -> init:'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_right : f:(char -> 'a -> 'a) -> string -> init:'a -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_right : f:(char -> 'acc -> 'acc) -> string -> init:'acc -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : f:(char -> 'acc -> 'acc) -> string -> init:'acc -> 'acc @since 4.13.0: val fold_right : f:(char -> 'a -> 'a) -> string -> init:'a -> 'a *) val for_all : f:(char -> bool) -> string -> bool (** @since 4.13.0: val for_all : f:(char -> bool) -> string -> bool *) val exists : f:(char -> bool) -> string -> bool (** @since 4.13.0: val exists : f:(char -> bool) -> string -> bool *) val get_uint8 : string -> int -> int (** @since 4.13.0: val get_uint8 : string -> int -> int *) val get_int8 : string -> int -> int (** @since 4.13.0: val get_int8 : string -> int -> int *) val get_uint16_ne : string -> int -> int (** @since 4.13.0: val get_uint16_ne : string -> int -> int *) val get_uint16_be : string -> int -> int (** @since 4.13.0: val get_uint16_be : string -> int -> int *) val get_uint16_le : string -> int -> int (** @since 4.13.0: val get_uint16_le : string -> int -> int *) val get_int16_ne : string -> int -> int (** @since 4.13.0: val get_int16_ne : string -> int -> int *) val get_int16_be : string -> int -> int (** @since 4.13.0: val get_int16_be : string -> int -> int *) val get_int16_le : string -> int -> int (** @since 4.13.0: val get_int16_le : string -> int -> int *) val get_int32_ne : string -> int -> int32 (** @since 4.13.0: val get_int32_ne : string -> int -> int32 *) val get_int32_be : string -> int -> int32 (** @since 4.13.0: val get_int32_be : string -> int -> int32 *) val get_int32_le : string -> int -> int32 (** @since 4.13.0: val get_int32_le : string -> int -> int32 *) val get_int64_ne : string -> int -> int64 (** @since 4.13.0: val get_int64_ne : string -> int -> int64 *) val get_int64_be : string -> int -> int64 (** @since 4.13.0: val get_int64_be : string -> int -> int64 *) val get_int64_le : string -> int -> int64 (** @since 4.13.0: val get_int64_le : string -> int -> int64 *) @BEGIN_FROM_4_07_0@ val to_seq : t -> char Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : t -> char Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : t -> char Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : t -> (int * char) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : t -> (int * char) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : t -> (int * char) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : char Seq.t -> t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : char Stdcompat__seq.t -> t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : char Seq.t -> t *) val equal : t -> t -> bool (** @since 4.05.0: val equal : t -> t -> bool *) val split_on_char : sep:char -> string -> string list (** @since 4.05.0: val split_on_char : sep:char -> string -> string list *) val uppercase_ascii : string -> string (** @since 4.05.0: val uppercase_ascii : string -> string *) val lowercase_ascii : string -> string (** @since 4.05.0: val lowercase_ascii : string -> string *) val capitalize_ascii : string -> string (** @since 4.05.0: val capitalize_ascii : string -> string *) val uncapitalize_ascii : string -> string (** @since 4.05.0: val uncapitalize_ascii : string -> string *) val index_from_opt : string -> int -> char -> int option (** @since 4.05.0: val index_from_opt : string -> int -> char -> int option *) val rindex_from_opt : string -> int -> char -> int option (** @since 4.05.0: val rindex_from_opt : string -> int -> char -> int option *) val index_opt : string -> char -> int option (** @since 4.05.0: val index_opt : string -> char -> int option *) val rindex_opt : string -> char -> int option (** @since 4.05.0: val rindex_opt : string -> char -> int option *) val init : int -> f:(int -> char) -> string (** @since 4.02.0: val init : int -> f:(int -> char) -> string *) @BEGIN_FROM_4_02_0@ val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val blit : src:string -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit *) val mapi : f:(int -> char -> char) -> string -> string (** @since 4.02.0: val mapi : f:(int -> char -> char) -> string -> string *) @BEGIN_FROM_4_03_0@ external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external unsafe_blit : src:string -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_blit : src:string -> src_pos:int -> dst:Stdcompat__init.bytes -> dst_pos:int -> len:int -> unit = "blit_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string"[@@noalloc ] @since 4.02.0: external unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit = "caml_blit_string" "noalloc" *) val map : f:(char -> char) -> string -> string (** @since 4.00.0: val map : f:(char -> char) -> string -> string *) val trim : string -> string (** @since 4.00.0: val trim : string -> string *) val iteri : f:(int -> char -> unit) -> string -> unit (** @since 4.00.0: val iteri : f:(int -> char -> unit) -> string -> unit *) val compare : t -> t -> int (** @since 3.08.0: val compare : t -> t -> int *) val make : int -> char -> string (** Alias for {!StringLabels.make} *) external length : string -> int = "%string_length" (** Alias for {!StringLabels.length} *) external get : string -> int -> char = "%string_safe_get" (** Alias for {!StringLabels.get} *) val concat : sep:string -> string list -> string (** Alias for {!StringLabels.concat} *) val contains_from : string -> int -> char -> bool (** Alias for {!StringLabels.contains_from} *) val rcontains_from : string -> int -> char -> bool (** Alias for {!StringLabels.rcontains_from} *) val contains : string -> char -> bool (** Alias for {!StringLabels.contains} *) val sub : string -> pos:int -> len:int -> string (** Alias for {!StringLabels.sub} *) val escaped : string -> string (** Alias for {!StringLabels.escaped} *) val iter : f:(char -> unit) -> string -> unit (** Alias for {!StringLabels.iter} *) val index_from : string -> int -> char -> int (** Alias for {!StringLabels.index_from} *) val rindex_from : string -> int -> char -> int (** Alias for {!StringLabels.rindex_from} *) val index : string -> char -> int (** Alias for {!StringLabels.index} *) val rindex : string -> char -> int (** Alias for {!StringLabels.rindex} *) external unsafe_get : string -> int -> char = "%string_unsafe_get" (** Alias for {!StringLabels.unsafe_get} *) end ocaml-stdcompat-20~git20240529/stdcompat__string_s.mli.in000066400000000000000000000227771463722102200233110ustar00rootroot00000000000000module type S = sig type t = string (** Alias for {!String.t} *) val hash : t -> int (** @since 5.0.0: val hash : t -> int *) val seeded_hash : int -> t -> int (** @since 5.0.0: val seeded_hash : int -> t -> int *) @BEGIN_FROM_4_14_0@ val get_utf_8_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_8_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_8_uchar : t -> int -> Uchar.utf_decode *) val is_valid_utf_8 : t -> bool (** @since 4.14.0: val is_valid_utf_8 : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16be_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16be_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16be_uchar : t -> int -> Uchar.utf_decode *) val is_valid_utf_16be : t -> bool (** @since 4.14.0: val is_valid_utf_16be : t -> bool *) @BEGIN_FROM_4_14_0@ val get_utf_16le_uchar : t -> int -> Uchar.utf_decode @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ val get_utf_16le_uchar : t -> int -> Stdcompat__uchar.utf_decode @END_BEFORE_4_14_0@ (** @since 4.14.0: val get_utf_16le_uchar : t -> int -> Uchar.utf_decode *) val is_valid_utf_16le : t -> bool (** @since 4.14.0: val is_valid_utf_16le : t -> bool *) val empty : string (** @since 4.13.0: val empty : string *) @BEGIN_FROM_4_13_0@ val of_bytes : bytes -> string @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val of_bytes : Stdcompat__init.bytes -> string @END_BEFORE_4_13_0@ (** @since 4.13.0: val of_bytes : bytes -> string *) @BEGIN_FROM_4_13_0@ val to_bytes : string -> bytes @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val to_bytes : string -> Stdcompat__init.bytes @END_BEFORE_4_13_0@ (** @since 4.13.0: val to_bytes : string -> bytes *) val cat : string -> string -> string (** @since 4.13.0: val cat : string -> string -> string *) val starts_with : prefix:string -> string -> bool (** @since 4.13.0: val starts_with : prefix:string -> string -> bool *) val ends_with : suffix:string -> string -> bool (** @since 4.13.0: val ends_with : suffix:string -> string -> bool *) @BEGIN_FROM_5_1_0@ val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc @since 4.13.0: val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a *) @BEGIN_FROM_5_1_0@ val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_13_0@ val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a @END_FROM_4_13_0@ @BEGIN_BEFORE_4_13_0@ val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc @END_BEFORE_4_13_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc @since 4.13.0: val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a *) val for_all : (char -> bool) -> string -> bool (** @since 4.13.0: val for_all : (char -> bool) -> string -> bool *) val exists : (char -> bool) -> string -> bool (** @since 4.13.0: val exists : (char -> bool) -> string -> bool *) val get_uint8 : string -> int -> int (** @since 4.13.0: val get_uint8 : string -> int -> int *) val get_int8 : string -> int -> int (** @since 4.13.0: val get_int8 : string -> int -> int *) val get_uint16_ne : string -> int -> int (** @since 4.13.0: val get_uint16_ne : string -> int -> int *) val get_uint16_be : string -> int -> int (** @since 4.13.0: val get_uint16_be : string -> int -> int *) val get_uint16_le : string -> int -> int (** @since 4.13.0: val get_uint16_le : string -> int -> int *) val get_int16_ne : string -> int -> int (** @since 4.13.0: val get_int16_ne : string -> int -> int *) val get_int16_be : string -> int -> int (** @since 4.13.0: val get_int16_be : string -> int -> int *) val get_int16_le : string -> int -> int (** @since 4.13.0: val get_int16_le : string -> int -> int *) val get_int32_ne : string -> int -> int32 (** @since 4.13.0: val get_int32_ne : string -> int -> int32 *) val get_int32_be : string -> int -> int32 (** @since 4.13.0: val get_int32_be : string -> int -> int32 *) val get_int32_le : string -> int -> int32 (** @since 4.13.0: val get_int32_le : string -> int -> int32 *) val get_int64_ne : string -> int -> int64 (** @since 4.13.0: val get_int64_ne : string -> int -> int64 *) val get_int64_be : string -> int -> int64 (** @since 4.13.0: val get_int64_be : string -> int -> int64 *) val get_int64_le : string -> int -> int64 (** @since 4.13.0: val get_int64_le : string -> int -> int64 *) @BEGIN_FROM_4_07_0@ val to_seq : t -> char Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : t -> char Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : t -> char Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : t -> (int * char) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : t -> (int * char) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : t -> (int * char) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : char Seq.t -> t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : char Stdcompat__seq.t -> t @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : char Seq.t -> t *) val index_from_opt : string -> int -> char -> int option (** @since 4.05.0: val index_from_opt : string -> int -> char -> int option *) val rindex_from_opt : string -> int -> char -> int option (** @since 4.05.0: val rindex_from_opt : string -> int -> char -> int option *) val index_opt : string -> char -> int option (** @since 4.05.0: val index_opt : string -> char -> int option *) val rindex_opt : string -> char -> int option (** @since 4.05.0: val rindex_opt : string -> char -> int option *) val split_on_char : char -> string -> string list (** @since 4.04.0: val split_on_char : char -> string -> string list *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) val uppercase_ascii : string -> string (** @since 4.03.0: val uppercase_ascii : string -> string *) val lowercase_ascii : string -> string (** @since 4.03.0: val lowercase_ascii : string -> string *) val capitalize_ascii : string -> string (** @since 4.03.0: val capitalize_ascii : string -> string *) val uncapitalize_ascii : string -> string (** @since 4.03.0: val uncapitalize_ascii : string -> string *) val init : int -> (int -> char) -> string (** @since 4.02.0: val init : int -> (int -> char) -> string *) @BEGIN_FROM_4_02_0@ val blit : string -> int -> bytes -> int -> int -> unit @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val blit : string -> int -> Stdcompat__init.bytes -> int -> int -> unit @END_BEFORE_4_02_0@ (** @since 4.02.0: val blit : string -> int -> bytes -> int -> int -> unit *) val mapi : (int -> char -> char) -> string -> string (** @since 4.02.0: val mapi : (int -> char -> char) -> string -> string *) @BEGIN_FROM_4_03_0@ external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string" "noalloc" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external unsafe_blit : string -> int -> Stdcompat__init.bytes -> int -> int -> unit = "caml_blit_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_blit : string -> int -> Stdcompat__init.bytes -> int -> int -> unit = "blit_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string" [@@noalloc ] @since 4.02.0: external unsafe_blit : string -> int -> bytes -> int -> int -> unit = "caml_blit_string" "noalloc" *) val map : (char -> char) -> string -> string (** @since 4.00.0: val map : (char -> char) -> string -> string *) val trim : string -> string (** @since 4.00.0: val trim : string -> string *) val iteri : (int -> char -> unit) -> string -> unit (** @since 4.00.0: val iteri : (int -> char -> unit) -> string -> unit *) val make : int -> char -> string (** Alias for {!String.make} *) external length : string -> int = "%string_length" (** Alias for {!String.length} *) external get : string -> int -> char = "%string_safe_get" (** Alias for {!String.get} *) val concat : string -> string list -> string (** Alias for {!String.concat} *) val compare : t -> t -> int (** Alias for {!String.compare} *) val contains_from : string -> int -> char -> bool (** Alias for {!String.contains_from} *) val rcontains_from : string -> int -> char -> bool (** Alias for {!String.rcontains_from} *) val contains : string -> char -> bool (** Alias for {!String.contains} *) val sub : string -> int -> int -> string (** Alias for {!String.sub} *) val escaped : string -> string (** Alias for {!String.escaped} *) val iter : (char -> unit) -> string -> unit (** Alias for {!String.iter} *) val index_from : string -> int -> char -> int (** Alias for {!String.index_from} *) val rindex_from : string -> int -> char -> int (** Alias for {!String.rindex_from} *) val index : string -> char -> int (** Alias for {!String.index} *) val rindex : string -> char -> int (** Alias for {!String.rindex} *) external unsafe_get : string -> int -> char = "%string_unsafe_get" (** Alias for {!String.unsafe_get} *) end ocaml-stdcompat-20~git20240529/stdcompat__stubs.c.in000066400000000000000000000046711463722102200222530ustar00rootroot00000000000000#include #include "stdcompat.h" @C_BEGIN_FROM_5_0_0@ void stdcompat_dummy_symbol() { /* If the library is empty, then the following error message appears on macOS: ld: archive has no table of contents file './libtest_prog_stubs.a' for architecture arm64 One solution is to execute `ranlib libtest_prog_stubs.a` after `ocamlmklib` and before `ocamlopt` use the library, but I don't know how to make dune execute the command. Another solution is to export a dummy symbol! */ } @C_END_FROM_5_0_0@ @C_BEGIN_BEFORE_4_12_0@ @C_BEGIN_FROM_4_04_0@ #include @C_END_FROM_4_04_0@ #define CAML_INTERNALS #include @C_BEGIN_FROM_4_04_0@ #include #include @C_END_FROM_4_04_0@ @C_BEGIN_BEFORE_4_04_0@ @C_BEGIN_BEFORE_3_08_0@ CAMLextern void sys_error (value); #define caml_sys_error sys_error @C_END_BEFORE_3_08_0@ @C_BEGIN_FROM_3_08_0@ CAMLextern void caml_sys_error (value); @C_END_FROM_3_08_0@ @C_END_BEFORE_4_04_0@ #ifdef _WIN32 #include #else #include #include #include #endif @C_BEGIN_BEFORE_3_08_0@ #define caml_alloc_string alloc_string @C_END_BEFORE_3_08_0@ CAMLprim value caml_sys_mkdir(value path, value perm) { CAMLparam2(path, perm); int ret; @C_BEGIN_FROM_4_06_0@ char_os * p = caml_stat_strdup_to_os(String_val(path)); #ifdef _WIN32 ret = _wmkdir(p); #else ret = mkdir(p, Int_val(perm)); #endif caml_stat_free(p); @C_END_FROM_4_06_0@ @C_BEGIN_BEFORE_4_06_0@ char * p; p = String_val(path); #ifdef _WIN32 ret = _mkdir(p); #else ret = mkdir(p, Int_val(perm)); #endif @C_END_BEFORE_4_06_0@ if (ret == -1) caml_sys_error(path); CAMLreturn(Val_unit); } CAMLprim value caml_sys_rmdir(value path) { CAMLparam1(path); int ret; @C_BEGIN_FROM_4_06_0@ char_os * p = caml_stat_strdup_to_os(String_val(path)); #ifdef _WIN32 ret = _wrmdir(p); #else ret = rmdir(p); #endif caml_stat_free(p); @C_END_FROM_4_06_0@ @C_BEGIN_BEFORE_4_06_0@ char * p; p = String_val(path); #ifdef _WIN32 ret = _rmdir(p); #else ret = rmdir(p); #endif @C_END_BEFORE_4_06_0@ if (ret == -1) caml_sys_error(path); CAMLreturn(Val_unit); } @C_END_BEFORE_4_12_0@ @C_BEGIN_BEFORE_4_06_0@ value caml_alloc_initialized_string(mlsize_t len, const char *p) { value result = caml_alloc_string(len); memcpy((char *)String_val(result), p, len); return result; } @C_END_BEFORE_4_06_0@ ocaml-stdcompat-20~git20240529/stdcompat__sys.ml.in000066400000000000000000000047511463722102200221160ustar00rootroot00000000000000include Sys @BEGIN_BEFORE_4_12_0@ external mkdir : string -> int -> unit = "caml_sys_mkdir" external rmdir : string -> unit = "caml_sys_rmdir" @END_BEFORE_4_12_0@ @BEGIN_BEFORE_4_10_0@ module Immediate64 = struct module type Non_immediate = sig type t end module type Immediate = sig type t @BEGIN_FROM_4_02_0@ [@@immediate] @END_FROM_4_02_0@ end module Make (Immediate : Immediate) (Non_immediate : Non_immediate) = struct type t = Non_immediate.t type 'a repr = @BEGIN_FROM_4_00_0@ | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ | Immediate | Non_immediate @END_BEFORE_4_00_0@ let repr = Non_immediate end end @END_BEFORE_4_10_0@ @BEGIN_BEFORE_4_08_0@ let max_floatarray_length = max_array_length / (64 / word_size) @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_05_0@ let getenv_opt var = Stdcompat__tools.option_find getenv var @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_04_0@ type backend_type = | Native | Bytecode | Other of string let backend_type = if Stdcompat__native.native then Native else Bytecode @END_BEFORE_4_04_0@ @BEGIN_BEFORE_4_03_0@ let sigbus = -22 let sigpoll = -23 let sigsys = -24 let sigtrap = -25 let sigurg = -26 let sigxcpu = -27 let sigxfsz = -28 let int_size = if 1 lsl word_size = 0 then word_size else if 1 lsl (word_size - 1) = 0 then word_size - 1 else assert false let big_endian = @BIG_ENDIAN@ let runtime_variant () = "" let runtime_parameters () = "" let enable_runtime_warnings _ = () let runtime_warnings_enabled () = false let opaque_identity x = x @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_01_0@ let unix = os_type = "Unix" let win32 = os_type = "Win32" let cygwin = os_type = "Cygwin" @END_BEFORE_4_01_0@ @BEGIN_BEFORE_3_10_0@ let is_directory path = try ignore (readdir path); true with Sys_error _ when file_exists path -> false @END_BEFORE_3_10_0@ @BEGIN_BEFORE_4_14_0@ let development_version = @OCAML_DEVELOPMENT_VERSION@ type extra_prefix = Plus | Tilde type extra_info = extra_prefix * string type ocaml_release_info = { major : int; minor : int; patchlevel : int; extra : extra_info option } let ocaml_release = { major = @OCAML_VERSION_MAJOR@; minor = @OCAML_VERSION_MINOR@; patchlevel = @OCAML_VERSION_PATCHLEVEL@; extra = @OCAML_RELEASE_EXTRA@ } @END_BEFORE_4_14_0@ @BEGIN_BEFORE_5_1_0@ let is_regular_file _path = failwith "not implemented" @END_BEFORE_5_1_0@ ocaml-stdcompat-20~git20240529/stdcompat__sys.mli.in000066400000000000000000000000331463722102200222540ustar00rootroot00000000000000include Stdcompat__sys_s.S ocaml-stdcompat-20~git20240529/stdcompat__sys_s.mli.in000066400000000000000000000263321463722102200226100ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_04_0@ type backend_type = Sys.backend_type = | Native | Bytecode | Other of string @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ type backend_type = | Native | Bytecode | Other of string @END_BEFORE_4_04_0@ (** @since 4.04.0: type backend_type = | Native | Bytecode | Other of string *) type signal_behavior = Sys.signal_behavior = | Signal_default | Signal_ignore | Signal_handle of (int -> unit) (** Alias for {!Sys.signal_behavior} *) exception Break (** Alias for {!Sys.Break} *) @BEGIN_FROM_4_14_0@ type extra_prefix = Sys.extra_prefix = | Plus | Tilde @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type extra_prefix = | Plus | Tilde @END_BEFORE_4_14_0@ (** @since 4.14.0: type extra_prefix = | Plus | Tilde *) @BEGIN_FROM_4_14_0@ type extra_info = (extra_prefix * string) @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type extra_info = (extra_prefix * string) @END_BEFORE_4_14_0@ (** @since 4.14.0: type extra_info = (extra_prefix * string) *) @BEGIN_FROM_4_14_0@ type ocaml_release_info = Sys.ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ type ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } @END_BEFORE_4_14_0@ (** @since 4.14.0: type ocaml_release_info = { major: int ; minor: int ; patchlevel: int ; extra: extra_info option } *) @BEGIN_FROM_4_10_0@ module Immediate64 = Sys.Immediate64 @END_FROM_4_10_0@ @BEGIN_BEFORE_4_10_0@ module Immediate64 : sig module type Non_immediate = sig type t end module type Immediate = sig @BEGIN_FROM_4_02_0@ type t[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t @END_BEFORE_4_02_0@ end module Make : functor (Immediate : Immediate) -> functor (Non_immediate : Non_immediate) -> sig @BEGIN_FROM_4_02_0@ type t[@@immediate64 ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t @END_BEFORE_4_02_0@ @BEGIN_FROM_4_00_0@ type 'a repr = | Immediate: Immediate.t repr | Non_immediate: Non_immediate.t repr @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ type 'a repr = | Immediate | Non_immediate @END_BEFORE_4_00_0@ val repr : t repr end end @END_BEFORE_4_10_0@ (** @since 4.10.0: module Immediate64 = Sys.Immediate64 *) @BEGIN_FROM_5_1_0@ external is_regular_file : string -> bool = "caml_sys_is_regular_file" @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ val is_regular_file : string -> bool @END_BEFORE_5_1_0@ (** @since 5.1.0: external is_regular_file : string -> bool = "caml_sys_is_regular_file" *) val development_version : bool (** @since 4.14.0: val development_version : bool *) val ocaml_release : ocaml_release_info (** @since 4.14.0: val ocaml_release : ocaml_release_info *) @BEGIN_FROM_4_12_0@ external mkdir : string -> int -> unit = "caml_sys_mkdir" @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ val mkdir : string -> int -> unit @END_BEFORE_4_12_0@ (** @since 4.12.0: external mkdir : string -> int -> unit = "caml_sys_mkdir" *) @BEGIN_FROM_4_12_0@ external rmdir : string -> unit = "caml_sys_rmdir" @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ val rmdir : string -> unit @END_BEFORE_4_12_0@ (** @since 4.12.0: external rmdir : string -> unit = "caml_sys_rmdir" *) val max_floatarray_length : int (** @since 4.08.0: val max_floatarray_length : int *) val getenv_opt : string -> string option (** @since 4.05.0: val getenv_opt : string -> string option *) val backend_type : backend_type (** @since 4.04.0: val backend_type : backend_type *) val int_size : int (** @since 4.03.0: val int_size : int *) @BEGIN_FROM_4_03_0@ external runtime_variant : unit -> string = "caml_runtime_variant" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val runtime_variant : unit -> string @END_BEFORE_4_03_0@ (** @since 4.03.0: external runtime_variant : unit -> string = "caml_runtime_variant" *) @BEGIN_FROM_4_03_0@ external runtime_parameters : unit -> string = "caml_runtime_parameters" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val runtime_parameters : unit -> string @END_BEFORE_4_03_0@ (** @since 4.03.0: external runtime_parameters : unit -> string = "caml_runtime_parameters" *) val sigbus : int (** @since 4.03.0: val sigbus : int *) val sigpoll : int (** @since 4.03.0: val sigpoll : int *) val sigsys : int (** @since 4.03.0: val sigsys : int *) val sigtrap : int (** @since 4.03.0: val sigtrap : int *) val sigurg : int (** @since 4.03.0: val sigurg : int *) val sigxcpu : int (** @since 4.03.0: val sigxcpu : int *) val sigxfsz : int (** @since 4.03.0: val sigxfsz : int *) val enable_runtime_warnings : bool -> unit (** @since 4.03.0: val enable_runtime_warnings : bool -> unit *) val runtime_warnings_enabled : unit -> bool (** @since 4.03.0: val runtime_warnings_enabled : unit -> bool *) @BEGIN_FROM_4_03_0@ external opaque_identity : 'a -> 'a = "%opaque" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val opaque_identity : 'a -> 'a @END_BEFORE_4_03_0@ (** @since 4.03.0: external opaque_identity : 'a -> 'a = "%opaque" *) val unix : bool (** @since 4.01.0: val unix : bool *) val win32 : bool (** @since 4.01.0: val win32 : bool *) val cygwin : bool (** @since 4.01.0: val cygwin : bool *) val big_endian : bool (** @since 4.00.0: val big_endian : bool *) @BEGIN_FROM_3_10_0@ external is_directory : string -> bool = "caml_sys_is_directory" @END_FROM_3_10_0@ @BEGIN_BEFORE_3_10_0@ val is_directory : string -> bool @END_BEFORE_3_10_0@ (** @since 3.10.0: external is_directory : string -> bool = "caml_sys_is_directory" *) @BEGIN_FROM_4_09_0@ external argv : string array = "%sys_argv" @END_FROM_4_09_0@ @BEGIN_BEFORE_4_09_0@ val argv : string array @END_BEFORE_4_09_0@ (** @since 4.09.0: external argv : string array = "%sys_argv" @since 3.07.0: val argv : string array *) val executable_name : string (** Alias for {!Sys.executable_name} *) @BEGIN_FROM_3_08_0@ external file_exists : string -> bool = "caml_sys_file_exists" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external file_exists : string -> bool = "sys_file_exists" @END_BEFORE_3_08_0@ (** @since 3.08.0: external file_exists : string -> bool = "caml_sys_file_exists" @since 3.07.0: external file_exists : string -> bool = "sys_file_exists" *) @BEGIN_FROM_3_08_0@ external remove : string -> unit = "caml_sys_remove" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external remove : string -> unit = "sys_remove" @END_BEFORE_3_08_0@ (** @since 3.08.0: external remove : string -> unit = "caml_sys_remove" @since 3.07.0: external remove : string -> unit = "sys_remove" *) @BEGIN_FROM_3_08_0@ external rename : string -> string -> unit = "caml_sys_rename" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external rename : string -> string -> unit = "sys_rename" @END_BEFORE_3_08_0@ (** @since 3.08.0: external rename : string -> string -> unit = "caml_sys_rename" @since 3.07.0: external rename : string -> string -> unit = "sys_rename" *) @BEGIN_FROM_3_08_0@ external getenv : string -> string = "caml_sys_getenv" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external getenv : string -> string = "sys_getenv" @END_BEFORE_3_08_0@ (** @since 3.08.0: external getenv : string -> string = "caml_sys_getenv" @since 3.07.0: external getenv : string -> string = "sys_getenv" *) @BEGIN_FROM_3_08_0@ external command : string -> int = "caml_sys_system_command" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external command : string -> int = "sys_system_command" @END_BEFORE_3_08_0@ (** @since 3.08.0: external command : string -> int = "caml_sys_system_command" @since 3.07.0: external command : string -> int = "sys_system_command" *) @BEGIN_FROM_4_03_0@ external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external time : unit -> float = "caml_sys_time" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external time : unit -> float = "sys_time" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] @since 3.08.0: external time : unit -> float = "caml_sys_time" @since 3.07.0: external time : unit -> float = "sys_time" *) @BEGIN_FROM_3_08_0@ external chdir : string -> unit = "caml_sys_chdir" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external chdir : string -> unit = "sys_chdir" @END_BEFORE_3_08_0@ (** @since 3.08.0: external chdir : string -> unit = "caml_sys_chdir" @since 3.07.0: external chdir : string -> unit = "sys_chdir" *) @BEGIN_FROM_3_08_0@ external getcwd : unit -> string = "caml_sys_getcwd" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external getcwd : unit -> string = "sys_getcwd" @END_BEFORE_3_08_0@ (** @since 3.08.0: external getcwd : unit -> string = "caml_sys_getcwd" @since 3.07.0: external getcwd : unit -> string = "sys_getcwd" *) @BEGIN_FROM_3_08_0@ external readdir : string -> string array = "caml_sys_read_directory" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external readdir : string -> string array = "sys_read_directory" @END_BEFORE_3_08_0@ (** @since 3.08.0: external readdir : string -> string array = "caml_sys_read_directory" @since 3.07.0: external readdir : string -> string array = "sys_read_directory" *) val interactive : bool ref (** Alias for {!Sys.interactive} *) val os_type : string (** Alias for {!Sys.os_type} *) val word_size : int (** Alias for {!Sys.word_size} *) val max_string_length : int (** Alias for {!Sys.max_string_length} *) val max_array_length : int (** Alias for {!Sys.max_array_length} *) @BEGIN_FROM_3_08_0@ external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external signal : int -> signal_behavior -> signal_behavior = "install_signal_handler" @END_BEFORE_3_08_0@ (** @since 3.08.0: external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" @since 3.07.0: external signal : int -> signal_behavior -> signal_behavior = "install_signal_handler" *) val set_signal : int -> signal_behavior -> unit (** Alias for {!Sys.set_signal} *) val sigabrt : int (** Alias for {!Sys.sigabrt} *) val sigalrm : int (** Alias for {!Sys.sigalrm} *) val sigfpe : int (** Alias for {!Sys.sigfpe} *) val sighup : int (** Alias for {!Sys.sighup} *) val sigill : int (** Alias for {!Sys.sigill} *) val sigint : int (** Alias for {!Sys.sigint} *) val sigkill : int (** Alias for {!Sys.sigkill} *) val sigpipe : int (** Alias for {!Sys.sigpipe} *) val sigquit : int (** Alias for {!Sys.sigquit} *) val sigsegv : int (** Alias for {!Sys.sigsegv} *) val sigterm : int (** Alias for {!Sys.sigterm} *) val sigusr1 : int (** Alias for {!Sys.sigusr1} *) val sigusr2 : int (** Alias for {!Sys.sigusr2} *) val sigchld : int (** Alias for {!Sys.sigchld} *) val sigcont : int (** Alias for {!Sys.sigcont} *) val sigstop : int (** Alias for {!Sys.sigstop} *) val sigtstp : int (** Alias for {!Sys.sigtstp} *) val sigttin : int (** Alias for {!Sys.sigttin} *) val sigttou : int (** Alias for {!Sys.sigttou} *) val sigvtalrm : int (** Alias for {!Sys.sigvtalrm} *) val sigprof : int (** Alias for {!Sys.sigprof} *) val catch_break : bool -> unit (** Alias for {!Sys.catch_break} *) val ocaml_version : string (** Alias for {!Sys.ocaml_version} *) end ocaml-stdcompat-20~git20240529/stdcompat__tools.ml.in000066400000000000000000000021361463722102200224330ustar00rootroot00000000000000@BEGIN_BEFORE_4_07_0@ let vec_to_seq length get v = let length = length v in let rec aux i () = if i = length then Stdcompat__seq.Nil else let x = get v i in Stdcompat__seq.Cons (x, aux (i + 1)) in aux 0 let vec_to_seqi length get v = let length = length v in let rec aux i () = if i = length then Stdcompat__seq.Nil else let x = get v i in Stdcompat__seq.Cons ((i, x), aux (i + 1)) in aux 0 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let option_find f x = try Some (f x) with Not_found -> None let option_fail f x = try Some (f x) with Failure _ -> None let option_invalid f x = try Some (f x) with Invalid_argument _ -> None exception Predicate_not_found let pickle_predicate_not_found p x = try p x with Not_found -> raise Predicate_not_found @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_03_0@ let rec uniq_rev_append cmp l accu = match l with | [] -> accu | [item] -> item :: accu | hd :: (hd' :: _ as tl) -> if cmp hd hd' = 0 then uniq_rev_append cmp tl accu else uniq_rev_append cmp tl (hd :: accu) @END_BEFORE_4_03_0@ ocaml-stdcompat-20~git20240529/stdcompat__tools.mli.in000066400000000000000000000011401463722102200225760ustar00rootroot00000000000000@BEGIN_BEFORE_4_07_0@ val vec_to_seq : ('a -> int) -> ('a -> int -> 'b) -> 'a -> 'b Stdcompat__seq.t val vec_to_seqi : ('a -> int) -> ('a -> int -> 'b) -> 'a -> (int * 'b) Stdcompat__seq.t @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ val option_find : ('a -> 'b) -> 'a -> 'b option val option_fail : ('a -> 'b) -> 'a -> 'b option val option_invalid : ('a -> 'b) -> 'a -> 'b option exception Predicate_not_found val pickle_predicate_not_found : ('a -> 'b) -> 'a -> 'b @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_03_0@ val uniq_rev_append : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list @END_BEFORE_4_03_0@ ocaml-stdcompat-20~git20240529/stdcompat__uchar.ml.in000066400000000000000000000035561463722102200224040ustar00rootroot00000000000000@BEGIN_FROM_4_03_0@ include Uchar @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_UCHAR_PKG@ include Uchar @END_WITH_UCHAR_PKG@ @BEGIN_WITHOUT_UCHAR_PKG@ type t = int let min = 0 let max = 0x10FFFF let lo_bound = 0xD7FF let hi_bound = 0xE000 let succ u = if u = lo_bound then hi_bound else if u = max then invalid_arg "Uchar.succ" else succ u let pred u = if u = hi_bound then lo_bound else if u = min then invalid_arg "Uchar.pred" else pred u let is_valid i = min <= i && i <= lo_bound || hi_bound <= i && i <= max let of_int i = if is_valid i then i else invalid_arg "Uchar.of_int" let unsafe_of_int i = i let to_int i = i let is_char u = u < 0x100 let of_char c = Char.code c let to_char u = if is_char u then Char.unsafe_chr u else invalid_arg "Uchar.to_char" let unsafe_to_char u = Char.unsafe_chr u let equal : t -> t -> bool = ( = ) let compare : t -> t -> int = compare let hash = to_int @END_WITHOUT_UCHAR_PKG@ @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_14_0@ let rep' = 0xFFFD type utf_decode = int let valid_bit = 27 let decode_bits = 24 let utf_decode_is_valid d = (d lsr valid_bit) = 1 let utf_decode_length d = (d lsr decode_bits) land 0b111 let utf_decode_uchar d = unsafe_of_int (d land 0xFFFFFF) let utf_decode n u = ((8 lor n) lsl decode_bits) lor (to_int u) let utf_decode_invalid n = (n lsl decode_bits) lor rep' let utf_8_byte_length u = match to_int u with | u when u < 0 -> assert false | u when u <= 0x007F -> 1 | u when u <= 0x07FF -> 2 | u when u <= 0xFFFF -> 3 | u when u <= 0x10FFFF -> 4 | _ -> assert false let utf_16_byte_length u = match to_int u with | u when u < 0 -> assert false | u when u <= 0xFFFF -> 2 | u when u <= 0x10FFFF -> 4 | _ -> assert false @END_BEFORE_4_14_0@ @BEGIN_BEFORE_4_06_0@ let bom = unsafe_of_int 0xFEFF let rep = unsafe_of_int rep' @END_BEFORE_4_06_0@ ocaml-stdcompat-20~git20240529/stdcompat__uchar.mli.in000066400000000000000000000000351463722102200225420ustar00rootroot00000000000000include Stdcompat__uchar_s.S ocaml-stdcompat-20~git20240529/stdcompat__uchar_s.mli.in000066400000000000000000000063711463722102200230750ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_14_0@ @BEGIN_WITH_UCHAR_PKG@ @BEGIN_FROM_4_02_0@ type t = Uchar.t[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = Uchar.t @END_BEFORE_4_02_0@ @END_WITH_UCHAR_PKG@ @BEGIN_WITHOUT_UCHAR_PKG@ @BEGIN_FROM_4_02_0@ type t = Uchar.t[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = Uchar.t @END_BEFORE_4_02_0@ @END_WITHOUT_UCHAR_PKG@ @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ @BEGIN_FROM_4_03_0@ @BEGIN_WITH_UCHAR_PKG@ type t = Uchar.t @END_WITH_UCHAR_PKG@ @BEGIN_WITHOUT_UCHAR_PKG@ type t = Uchar.t @END_WITHOUT_UCHAR_PKG@ @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_UCHAR_PKG@ @BEGIN_FROM_4_02_0@ type t = Uchar.t[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t = Uchar.t @END_BEFORE_4_02_0@ @END_WITH_UCHAR_PKG@ @BEGIN_WITHOUT_UCHAR_PKG@ @BEGIN_FROM_4_02_0@ type t[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type t @END_BEFORE_4_02_0@ @END_WITHOUT_UCHAR_PKG@ @END_BEFORE_4_03_0@ @END_BEFORE_4_14_0@ (** @since 4.14.0: type t[@@immediate ] @since 4.03.0: type t *) @BEGIN_FROM_4_14_0@ @BEGIN_FROM_4_02_0@ type utf_decode = Uchar.utf_decode[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type utf_decode = Uchar.utf_decode @END_BEFORE_4_02_0@ @END_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ @BEGIN_FROM_4_02_0@ type utf_decode[@@immediate ] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type utf_decode @END_BEFORE_4_02_0@ @END_BEFORE_4_14_0@ (** @since 4.14.0: type utf_decode[@@immediate ] *) val utf_decode_is_valid : utf_decode -> bool (** @since 4.14.0: val utf_decode_is_valid : utf_decode -> bool *) val utf_decode_uchar : utf_decode -> t (** @since 4.14.0: val utf_decode_uchar : utf_decode -> t *) val utf_decode_length : utf_decode -> int (** @since 4.14.0: val utf_decode_length : utf_decode -> int *) val utf_decode : int -> t -> utf_decode (** @since 4.14.0: val utf_decode : int -> t -> utf_decode *) val utf_decode_invalid : int -> utf_decode (** @since 4.14.0: val utf_decode_invalid : int -> utf_decode *) val utf_8_byte_length : t -> int (** @since 4.14.0: val utf_8_byte_length : t -> int *) val utf_16_byte_length : t -> int (** @since 4.14.0: val utf_16_byte_length : t -> int *) val bom : t (** @since 4.06.0: val bom : t *) val rep : t (** @since 4.06.0: val rep : t *) val min : t (** @since 4.03.0: val min : t *) val max : t (** @since 4.03.0: val max : t *) val succ : t -> t (** @since 4.03.0: val succ : t -> t *) val pred : t -> t (** @since 4.03.0: val pred : t -> t *) val is_valid : int -> bool (** @since 4.03.0: val is_valid : int -> bool *) val of_int : int -> t (** @since 4.03.0: val of_int : int -> t *) val unsafe_of_int : int -> t (** @since 4.03.0: val unsafe_of_int : int -> t *) val to_int : t -> int (** @since 4.03.0: val to_int : t -> int *) val is_char : t -> bool (** @since 4.03.0: val is_char : t -> bool *) val of_char : char -> t (** @since 4.03.0: val of_char : char -> t *) val to_char : t -> char (** @since 4.03.0: val to_char : t -> char *) val unsafe_to_char : t -> char (** @since 4.03.0: val unsafe_to_char : t -> char *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) val compare : t -> t -> int (** @since 4.03.0: val compare : t -> t -> int *) val hash : t -> int (** @since 4.03.0: val hash : t -> int *) end ocaml-stdcompat-20~git20240529/stdcompat__unit.ml.in000066400000000000000000000002701463722102200222470ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type t = unit = () let equal () () = true let compare () () = 0 let to_string () = "()" @END_BEFORE_4_08_0@ ocaml-stdcompat-20~git20240529/stdcompat__unit.mli.in000066400000000000000000000000341463722102200224160ustar00rootroot00000000000000include Stdcompat__unit_s.S ocaml-stdcompat-20~git20240529/stdcompat__unit_s.mli.in000066400000000000000000000007061463722102200227460ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type t = unit = | () @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type t = unit = | () @END_BEFORE_4_08_0@ (** @since 4.08.0: type t = unit = | () *) val equal : t -> t -> bool (** @since 4.08.0: val equal : t -> t -> bool *) val compare : t -> t -> int (** @since 4.08.0: val compare : t -> t -> int *) val to_string : t -> string (** @since 4.08.0: val to_string : t -> string *) end ocaml-stdcompat-20~git20240529/stdcompat__weak.ml.in000066400000000000000000000017241463722102200222240ustar00rootroot00000000000000type 'a t = 'a Weak.t let create = Weak.create let length = Weak.length let set = Weak.set let get = Weak.get let get_copy = Weak.get_copy let check = Weak.check let fill = Weak.fill let blit = Weak.blit @BEGIN_FROM_4_05_0@ module type S = Weak.S module Make = Weak.Make @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> int * int * int * int * int * int end module Make (H : Hashtbl.HashedType) = struct include Weak.Make (H) let find_opt t d = Stdcompat__tools.option_find (find t) d end @END_BEFORE_4_05_0@ ocaml-stdcompat-20~git20240529/stdcompat__weak.mli.in000066400000000000000000000000341463722102200223660ustar00rootroot00000000000000include Stdcompat__weak_s.S ocaml-stdcompat-20~git20240529/stdcompat__weak_s.mli.in000066400000000000000000000101351463722102200227130ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_12_0@ type !'a t = 'a Weak.t @END_FROM_4_12_0@ @BEGIN_BEFORE_4_12_0@ type 'a t = 'a Weak.t @END_BEFORE_4_12_0@ (** Alias for {!Weak.t} *) @BEGIN_FROM_5_1_0@ module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end @END_FROM_5_1_0@ @BEGIN_BEFORE_5_1_0@ @BEGIN_FROM_4_05_0@ module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end @END_BEFORE_4_05_0@ @END_BEFORE_5_1_0@ (** @since 5.1.0: module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end @since 4.05.0: module type S = sig type data type t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end *) @BEGIN_FROM_4_05_0@ module Make = Weak.Make @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ module Make : functor (H : Hashtbl.HashedType) -> sig type data = H.t type t = Weak.Make(H).t val create : int -> t val clear : t -> unit val merge : t -> data -> data val add : t -> data -> unit val remove : t -> data -> unit val find : t -> data -> data val find_opt : t -> data -> data option val find_all : t -> data -> data list val mem : t -> data -> bool val iter : (data -> unit) -> t -> unit val fold : (data -> 'acc -> 'acc) -> t -> 'acc -> 'acc val count : t -> int val stats : t -> (int * int * int * int * int * int) end @END_BEFORE_4_05_0@ (** @since 4.05.0: module Make = Weak.Make *) val create : int -> 'a t (** Alias for {!Weak.create} *) val length : 'a t -> int (** Alias for {!Weak.length} *) val set : 'a t -> int -> 'a option -> unit (** Alias for {!Weak.set} *) val get : 'a t -> int -> 'a option (** Alias for {!Weak.get} *) val get_copy : 'a t -> int -> 'a option (** Alias for {!Weak.get_copy} *) val check : 'a t -> int -> bool (** Alias for {!Weak.check} *) val fill : 'a t -> int -> int -> 'a option -> unit (** Alias for {!Weak.fill} *) val blit : 'a t -> int -> 'a t -> int -> int -> unit (** Alias for {!Weak.blit} *) end ocaml-stdcompat-20~git20240529/stdcompat_tests.ml.in000066400000000000000000001626341463722102200223100ustar00rootroot00000000000000let failed = ref false let testing s f = Printf.printf "Testing %s..." s; flush stdout; try f (); print_endline " OK" with exc -> print_endline (Printexc.to_string exc); failed := true let test_array_for_all2 () = let visited = ref [] in let p i s = visited := i :: !visited; String.make 1 (char_of_int ((int_of_char 'a') + i)) = s in assert ( Stdcompat.Array.for_all2 p [| 0; 1; 2; 3 |] [| "a"; "b"; "c"; "d" |]); assert (List.rev !visited = [0; 1; 2; 3]); visited := []; let p i s = visited := i :: !visited; String.make 1 (char_of_int ((int_of_char 'a') + i)) = s && i <> 2 in assert (not ( Stdcompat.Array.for_all2 p [| 0; 1; 2; 3 |] [| "a"; "b"; "c"; "d" |])); assert (List.rev !visited = [0; 1; 2]); visited := []; assert ( try ignore ( Stdcompat.Array.for_all2 p [| 0; 1; 2; 3 |] [| "a"; "b"; "c" |]); false with Invalid_argument _ -> true); assert (List.rev !visited = []) let test_array_exists2 () = let visited = ref [] in let p i s = visited := i :: !visited; String.make 1 (char_of_int ((int_of_char 'a') + i)) <> s in assert (not ( Stdcompat.Array.exists2 p [| 0; 1; 2; 3 |] [| "a"; "b"; "c"; "d" |])); assert (List.rev !visited = [0; 1; 2; 3]); visited := []; let p i s = visited := i :: !visited; String.make 1 (char_of_int ((int_of_char 'a') + i)) <> s || i = 2 in assert ( Stdcompat.Array.exists2 p [| 0; 1; 2; 3 |] [| "a"; "b"; "c"; "d" |]); assert (List.rev !visited = [0; 1; 2]); visited := []; assert ( try ignore ( Stdcompat.Array.exists2 p [| 0; 1; 2; 3 |] [| "a"; "b"; "c" |]); false with Invalid_argument _ -> true); assert (List.rev !visited = []) let test_list_filteri () = let visited = ref [] in let p i s = visited := i :: !visited; assert (string_of_int i = s); i mod 2 = 0 in assert ( Stdcompat.List.filteri p (Stdcompat.List.init 6 string_of_int) = ["0"; "2"; "4"]); assert (List.rev !visited = [0; 1; 2; 3; 4; 5]) let test_list_fold_left_map () = let visited = ref [] in let f accu s = visited := s :: !visited; accu ^ s, "a" ^ s in assert ( Stdcompat.List.fold_left_map f "" (Stdcompat.List.init 6 string_of_int) = ("012345", ["a0"; "a1"; "a2"; "a3"; "a4"; "a5"])); assert (List.rev !visited = ["0"; "1"; "2"; "3"; "4"; "5"]) let test_seq_cons () = assert ( Stdcompat.List.of_seq (Stdcompat.Seq.cons 0 (Stdcompat.Seq.cons 1 (Stdcompat.List.to_seq [2; 3]))) = [0; 1; 2; 3]) let test_seq_append () = assert ( Stdcompat.List.of_seq (Stdcompat.Seq.append (Stdcompat.List.to_seq [0; 1; 2]) (Stdcompat.List.to_seq [3; 4; 5])) = [0; 1; 2; 3; 4; 5]) let test_seq_unfold () = assert ( Stdcompat.List.of_seq (Stdcompat.Seq.unfold (fun i -> if i < 5 then Some (string_of_int i, i + 1) else None) 0) = ["0"; "1"; "2"; "3"; "4"]) let test_set_filter_map () = let module Set = Stdcompat.Set.Make (Stdcompat.Int) in let visited = ref [] in assert ( let original_set = Set.of_seq (Stdcompat.List.to_seq (Stdcompat.List.init 6 Stdcompat.Fun.id)) in let new_set = Set.filter_map (fun i -> visited := i :: !visited; if i mod 2 = 0 then Some (6 - i / 2) else None) original_set in let elements = Set.elements new_set in List.sort compare elements = [4; 5; 6]); assert (List.rev !visited = [0; 1; 2; 3; 4; 5]) let test_map_filter_map () = let module Map = Stdcompat.Map.Make (Stdcompat.Int) in let visited = ref [] in assert ( List.sort compare (Map.bindings (Map.filter_map (fun k s -> visited := k :: !visited; assert (string_of_int k = s); if k mod 2 = 0 then Some ("a" ^ s) else None) (Map.of_seq (Stdcompat.List.to_seq (Stdcompat.List.init 6 (fun i -> i, string_of_int i)))))) = [0, "a0"; 2, "a2"; 4, "a4"]); assert (List.rev !visited = [0; 1; 2; 3; 4; 5]) let test_mkdir_rmdir () = Stdcompat.Sys.mkdir "new_directory" 0o600; assert (Stdcompat.Sys.is_directory "new_directory"); begin try Stdcompat.Sys.mkdir "new_directory" 0o600; assert false; with Sys_error _ -> assert true; end; Stdcompat.Sys.rmdir "new_directory"; begin try Stdcompat.Sys.rmdir "new_directory"; assert false; with Sys_error _ -> assert true; end let test_set_to_seq_to_rev_seq () = let module M = Stdcompat.Set.Make (Stdcompat.Int) in let s = M.add 2 (M.add 1 (M.add 3 M.empty)) in assert (Stdcompat.List.of_seq (M.to_seq s) = [1; 2; 3]); assert (Stdcompat.List.of_seq (M.to_rev_seq s) = [3; 2; 1]) let test_map_to_seq_to_rev_seq () = let module M = Stdcompat.Map.Make (Stdcompat.Int) in let s = M.add 2 () (M.add 1 () (M.add 3 () M.empty)) in assert (Stdcompat.List.of_seq (M.to_seq s) = [1, (); 2, (); 3, ()]); assert (Stdcompat.List.of_seq (M.to_rev_seq s) = [3, (); 2, (); 1, ()]) let test_list_partition_map () = assert (Stdcompat.List.partition_map (fun i -> if i > 0 then Stdcompat.Either.Left i else Stdcompat.Either.Right (-i)) [1; -2; 3; -4; 5; -6] = ([1; 3; 5], [2; 4; 6])) let test_list_compare () = let l1 = [1; 2; 3; 4] in let l2 = [1; 2; 4; 3] in let l3 = [1; 2; 5; 6] in assert (Stdcompat.List.compare Stdcompat.Int.compare l1 l1 = 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l1 l2 < 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l1 l3 < 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l2 l1 > 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l2 l2 = 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l2 l3 < 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l3 l1 > 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l3 l2 > 0); assert (Stdcompat.List.compare Stdcompat.Int.compare l3 l3 = 0) let test_list_equal () = let l1 = [1; 2; 3; 4] in let l2 = [1; 2; 4; 3] in let l3 = [1; 2; 5; 6] in assert (Stdcompat.List.equal Stdcompat.Int.equal l1 l1); assert (not (Stdcompat.List.equal Stdcompat.Int.equal l1 l2)); assert (not (Stdcompat.List.equal Stdcompat.Int.equal l1 l3)); assert (not (Stdcompat.List.equal Stdcompat.Int.equal l2 l1)); assert (Stdcompat.List.equal Stdcompat.Int.equal l2 l2); assert (not (Stdcompat.List.equal Stdcompat.Int.equal l2 l3)); assert (not (Stdcompat.List.equal Stdcompat.Int.equal l3 l1)); assert (not (Stdcompat.List.equal Stdcompat.Int.equal l3 l2)); assert (Stdcompat.List.equal Stdcompat.Int.equal l3 l3) let test_hashtbl_rebuild () = let h = Hashtbl.create 17 in Hashtbl.add h 1 (); Hashtbl.add h 2 (); Hashtbl.add h 3 (); let h' = Stdcompat.Hashtbl.rebuild h in let module M = Stdcompat.Set.Make (Stdcompat.Int) in assert ( M.equal (M.of_seq (Stdcompat.Seq.map fst (Stdcompat.Hashtbl.to_seq h'))) (M.add 1 (M.add 2 (M.add 3 M.empty)))) let test_format_pp_print_seq () = let buffer = Buffer.create 17 in Format.fprintf (Format.formatter_of_buffer buffer) "%a@." (Stdcompat.Format.pp_print_seq ~pp_sep:(fun fmt () -> Format.pp_print_string fmt ",") Format.pp_print_int) (Stdcompat.List.to_seq [1; 2; 3]); assert (Buffer.contents buffer = "1,2,3\n") let test_either () = assert (Stdcompat.Either.compare ~left:Stdcompat.Int.compare ~right:Stdcompat.Int.compare (Stdcompat.Either.Left 1) (Stdcompat.Either.Left 1) = 0); assert (Stdcompat.Either.compare ~left:Stdcompat.Int.compare ~right:Stdcompat.Int.compare (Stdcompat.Either.Left 1) (Stdcompat.Either.Left 2) < 0); assert (Stdcompat.Either.compare ~left:Stdcompat.Int.compare ~right:Stdcompat.Int.compare (Stdcompat.Either.Left 1) (Stdcompat.Either.Right 2) < 0); assert (Stdcompat.Either.compare ~left:Stdcompat.Int.compare ~right:Stdcompat.Int.compare (Stdcompat.Either.Right 1) (Stdcompat.Either.Left 2) > 0); assert (Stdcompat.Either.compare ~left:Stdcompat.Int.compare ~right:Stdcompat.Int.compare (Stdcompat.Either.Right 1) (Stdcompat.Either.Right 2) < 0) let test_seq_concat () = assert (Stdcompat.List.of_seq (Stdcompat.Seq.concat (Stdcompat.Seq.map Stdcompat.List.to_seq (Stdcompat.List.to_seq [[1; 2]; []; [3]; [4; 5]]))) = [1; 2; 3; 4; 5]); assert (Stdcompat.List.of_seq (Stdcompat.Seq.concat_map Stdcompat.List.to_seq (Stdcompat.List.to_seq [[1; 2]; []; [3]; [4; 5]])) = [1; 2; 3; 4; 5]) let test_seq_is_empty () = assert (Stdcompat.Seq.is_empty Stdcompat.Seq.empty); assert (not ( Stdcompat.Seq.is_empty ( Stdcompat.Seq.once (Stdcompat.Seq.cons () Stdcompat.Seq.empty)))) let test_seq_uncons () = assert (Stdcompat.Seq.uncons Stdcompat.Seq.empty = None); begin match Stdcompat.Seq.uncons (Stdcompat.Seq.once (Stdcompat.Seq.cons () Stdcompat.Seq.empty)) with | None -> assert false | Some ((), tl) -> assert (Stdcompat.Seq.uncons tl = None) end let test_seq_length () = let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert (Stdcompat.Seq.length s = 6) let test_seq_iteri () = let accu = ref [] in let add i j = accu := (i, j) :: !accu in Stdcompat.Seq.iteri add (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))) let test_seq_fold_lefti () = let add accu i j = (i, j) :: accu in let accu = Stdcompat.Seq.fold_lefti add [] (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) in assert (List.rev accu = Stdcompat.List.init 6 (fun i -> (i, i))) let test_seq_forall () = assert (Stdcompat.Seq.for_all (fun _ -> raise Exit) Stdcompat.Seq.empty); let accu = ref [] in let add i = accu := i :: !accu in assert (Stdcompat.Seq.for_all (fun i -> add i; true) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id))); assert (List.rev !accu = Stdcompat.List.init 6 Stdcompat.Fun.id); accu := []; assert (not (Stdcompat.Seq.for_all (fun i -> add i; i <> 4) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)))); assert (List.rev !accu = Stdcompat.List.init 5 Stdcompat.Fun.id) let test_seq_exists () = assert (not (Stdcompat.Seq.exists (fun _ -> raise Exit) Stdcompat.Seq.empty)); let accu = ref [] in let add i = accu := i :: !accu in assert (not (Stdcompat.Seq.exists (fun i -> add i; false) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)))); assert (List.rev !accu = Stdcompat.List.init 6 Stdcompat.Fun.id); accu := []; assert (Stdcompat.Seq.exists (fun i -> add i; i = 4) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id))); assert (List.rev !accu = Stdcompat.List.init 5 Stdcompat.Fun.id) let test_seq_find () = assert (Stdcompat.Seq.find (fun _ -> raise Exit) Stdcompat.Seq.empty = None); let accu = ref [] in let add i = accu := i :: !accu in assert (Stdcompat.Seq.find (fun i -> add i; false) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) = None); assert (List.rev !accu = Stdcompat.List.init 6 Stdcompat.Fun.id); accu := []; assert (Stdcompat.Seq.find (fun i -> add i; i = 4) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) = Some 4); assert (List.rev !accu = Stdcompat.List.init 5 Stdcompat.Fun.id) let test_seq_find_map () = assert ( Stdcompat.Seq.find_map (fun _ -> raise Exit) Stdcompat.Seq.empty = None); let accu = ref [] in let add i = accu := i :: !accu in assert (Stdcompat.Seq.find_map (fun i -> add i; None) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) = None); assert (List.rev !accu = Stdcompat.List.init 6 Stdcompat.Fun.id); accu := []; assert (Stdcompat.Seq.find_map (fun i -> add i; if i = 4 then Some i else None) (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) = Some 4); assert (List.rev !accu = Stdcompat.List.init 5 Stdcompat.Fun.id) let test_seq_iter2 () = let test_with_lengths i j = let accu = ref [] in let add i j = accu := (i, j) :: !accu in Stdcompat.Seq.iter2 add (Stdcompat.Seq.once (Stdcompat.Seq.init i Stdcompat.Fun.id)) (Stdcompat.Seq.once (Stdcompat.Seq.init j Stdcompat.Fun.id)); assert (List.rev !accu = Stdcompat.List.init (min i j) (fun i -> (i, i))) in test_with_lengths 6 6; test_with_lengths 6 7; test_with_lengths 7 6 let test_seq_fold_left2 () = let test_with_lengths i j = let add accu i j = (i, j) :: accu in let accu = Stdcompat.Seq.fold_left2 add [] (Stdcompat.Seq.once (Stdcompat.Seq.init i Stdcompat.Fun.id)) (Stdcompat.Seq.once (Stdcompat.Seq.init j Stdcompat.Fun.id)) in assert (List.rev accu = Stdcompat.List.init (min i j) (fun i -> (i, i))) in test_with_lengths 6 6; test_with_lengths 6 7; test_with_lengths 7 6 let test_seq_for_all2 () = let test_with_lengths i j p = Stdcompat.Seq.for_all2 p (Stdcompat.Seq.once (Stdcompat.Seq.init i Stdcompat.Fun.id)) (Stdcompat.Seq.once (Stdcompat.Seq.init j Stdcompat.Fun.id)) in assert (test_with_lengths 0 0 (fun _ _ -> raise Exit)); assert (test_with_lengths 0 6 (fun _ _ -> raise Exit)); assert (test_with_lengths 6 0 (fun _ _ -> raise Exit)); let accu = ref [] in let add i j = accu := (i, j) :: !accu in assert (test_with_lengths 6 6 (fun i j -> add i j; true)); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (test_with_lengths 6 7 (fun i j -> add i j; true)); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (test_with_lengths 7 6 (fun i j -> add i j; true)); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (not (test_with_lengths 6 6 (fun i j -> add i j; i < 4))); assert (List.rev !accu = Stdcompat.List.init 5 (fun i -> (i, i))) let test_seq_exists2 () = let test_with_lengths i j p = Stdcompat.Seq.exists2 p (Stdcompat.Seq.once (Stdcompat.Seq.init i Stdcompat.Fun.id)) (Stdcompat.Seq.once (Stdcompat.Seq.init j Stdcompat.Fun.id)) in assert (not (test_with_lengths 0 0 (fun _ _ -> raise Exit))); assert (not (test_with_lengths 0 6 (fun _ _ -> raise Exit))); assert (not (test_with_lengths 6 0 (fun _ _ -> raise Exit))); let accu = ref [] in let add i j = accu := (i, j) :: !accu in assert (not (test_with_lengths 6 6 (fun i j -> add i j; false))); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (not (test_with_lengths 6 7 (fun i j -> add i j; false))); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (not (test_with_lengths 7 6 (fun i j -> add i j; false))); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (test_with_lengths 6 6 (fun i j -> add i j; i = 4)); assert (List.rev !accu = Stdcompat.List.init 5 (fun i -> (i, i))) let test_seq_equal () = let test_with_lengths i j p = Stdcompat.Seq.equal p (Stdcompat.Seq.once (Stdcompat.Seq.init i Stdcompat.Fun.id)) (Stdcompat.Seq.once (Stdcompat.Seq.init j Stdcompat.Fun.id)) in assert (test_with_lengths 0 0 (fun _ _ -> raise Exit)); assert (not (test_with_lengths 0 6 (fun _ _ -> raise Exit))); assert (not (test_with_lengths 6 0 (fun _ _ -> raise Exit))); let accu = ref [] in let add i j = accu := (i, j) :: !accu in assert (test_with_lengths 6 6 (fun i j -> add i j; true)); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (not (test_with_lengths 6 7 (fun i j -> add i j; true))); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (not (test_with_lengths 7 6 (fun i j -> add i j; true))); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (not (test_with_lengths 6 6 (fun i j -> add i j; i < 4))); assert (List.rev !accu = Stdcompat.List.init 5 (fun i -> (i, i))) let test_seq_compare () = let test_with_lengths i j p = Stdcompat.Seq.compare p (Stdcompat.Seq.once (Stdcompat.Seq.init i Stdcompat.Fun.id)) (Stdcompat.Seq.once (Stdcompat.Seq.init j Stdcompat.Fun.id)) in assert (test_with_lengths 0 0 (fun _ _ -> raise Exit) = 0); assert (test_with_lengths 0 6 (fun _ _ -> raise Exit) = -1); assert (test_with_lengths 6 0 (fun _ _ -> raise Exit) = 1); let accu = ref [] in let add i j = accu := (i, j) :: !accu in assert (test_with_lengths 6 6 (fun i j -> add i j; 0) = 0); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (test_with_lengths 6 7 (fun i j -> add i j; 0) = -1); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (test_with_lengths 7 6 (fun i j -> add i j; 0) = 1); assert (List.rev !accu = Stdcompat.List.init 6 (fun i -> (i, i))); accu := []; assert (test_with_lengths 6 6 (fun i j -> add i j; if i = 4 then 1 else 0) = 1); assert (List.rev !accu = Stdcompat.List.init 5 (fun i -> (i, i))); accu := []; assert (test_with_lengths 6 6 (fun i j -> add i j; if i = 4 then -1 else 0) = -1); assert (List.rev !accu = Stdcompat.List.init 5 (fun i -> (i, i))) let test_seq_init () = begin try let _ = Stdcompat.Seq.init (-1) (fun _ -> raise Exit) () in assert false with Invalid_argument _ -> () end; let accu = ref [] in let s = Stdcompat.Seq.init 6 (fun i -> accu := i :: !accu; i) in assert (!accu = []); assert (Stdcompat.List.of_seq s = Stdcompat.List.init 6 Stdcompat.Fun.id); assert (List.rev !accu = Stdcompat.List.init 6 Stdcompat.Fun.id) let test_seq_repeat () = let s = Stdcompat.Seq.repeat () in assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = Stdcompat.List.init 6 (fun _ -> ())) let test_seq_forever () = let value_ref = ref None in let s = Stdcompat.Seq.forever (fun () -> let value = Stdcompat.Option.get !value_ref in value_ref := None; value) in value_ref := Some 1; let hd, s' = Stdcompat.Option.get (Stdcompat.Seq.uncons s) in assert (hd = 1); value_ref := Some 2; let hd, _s'' = Stdcompat.Option.get (Stdcompat.Seq.uncons s') in assert (hd = 2); value_ref := Some 3; let hd, _s''' = Stdcompat.Option.get (Stdcompat.Seq.uncons s) in assert (hd = 3) let test_seq_cycle () = let s = Stdcompat.Seq.cycle (Stdcompat.Seq.init 3 Stdcompat.Fun.id) in assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 4 s) = [0; 1; 2; 0]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 5 s) = [0; 1; 2; 0; 1]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [0; 1; 2; 0; 1; 2]) let test_seq_iterate () = let called = ref 0 in let s = Stdcompat.Seq.iterate (fun x -> incr called; x + 1) 0 in assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 4 s) = [0; 1; 2; 3]); called := 3; assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 5 s) = [0; 1; 2; 3; 4]); called := 7; assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [0; 1; 2; 3; 4; 5]); called := 13 let test_seq_mapi () = assert ( Stdcompat.List.of_seq (Stdcompat.Seq.mapi (fun i j -> (i, j)) (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) = Stdcompat.List.init 6 (fun i -> (i, i))) let test_seq_scan () = assert ( Stdcompat.List.of_seq ( Stdcompat.Seq.scan ( + ) 0 (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id))) = [0; 0; 1; 3; 6; 10; 15]) let test_seq_take () = begin try let _ = Stdcompat.Seq.take (-1) (fun _ -> raise Exit) () in assert false with Invalid_argument _ -> () end; assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.take 0 (fun _ -> raise Exit))); let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 4 s) = [0; 1; 2; 3]); let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [0; 1; 2; 3; 4; 5]) let test_seq_drop () = begin try let _ = Stdcompat.Seq.drop (-1) (fun _ -> raise Exit) () in assert false with Invalid_argument _ -> () end; let _f = Stdcompat.Seq.drop 0 (fun _ -> raise Exit) in let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert ( Stdcompat.List.of_seq (Stdcompat.Seq.drop 4 s) = [4; 5]); let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.drop 6 s)) let test_seq_take_while () = let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take_while (fun _i -> false) s) = []); let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take_while (fun i -> i < 3) s) = [0; 1; 2]); let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take_while (fun _i -> true) s) = [0; 1; 2; 3; 4; 5]) let test_seq_drop_while () = let s = Stdcompat.Seq.init 6 Stdcompat.Fun.id in assert (Stdcompat.List.of_seq (Stdcompat.Seq.drop_while (fun i -> i < 3) s) = [3; 4; 5]); let s = Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id) in assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.drop_while (fun _i -> true) s)) let test_seq_group () = let s = Stdcompat.Seq.group (fun i j -> i / 3 = j / 3) (Stdcompat.Seq.ints 0) in let l012, tl = Stdcompat.Option.get (Stdcompat.Seq.uncons s) in let l345, _tl = Stdcompat.Option.get (Stdcompat.Seq.uncons tl) in assert (Stdcompat.List.of_seq l345 = [3; 4; 5]); assert (Stdcompat.List.of_seq l012 = [0; 1; 2]); let s = Stdcompat.Seq.group (fun _i _j -> true) (Stdcompat.Seq.ints 0) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 3 (fst (Stdcompat.Option.get (Stdcompat.Seq.uncons s)))) = [0; 1; 2]) let test_seq_memoize () = let s = Stdcompat.Seq.memoize (Stdcompat.Seq.once (Stdcompat.Seq.ints 0)) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 3 s) = [0; 1; 2]); assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 4 s) = [0; 1; 2; 3]) let test_seq_once () = let s = Stdcompat.Seq.once (Stdcompat.Seq.ints 0) in let hd, tl = Stdcompat.Option.get (Stdcompat.Seq.uncons s) in assert (hd = 0); begin try ignore (Stdcompat.Seq.uncons s); assert false with Stdcompat.Seq.Forced_twice -> () end; let hd', tl' = Stdcompat.Option.get (Stdcompat.Seq.uncons tl) in assert (hd' = 1); begin try ignore (Stdcompat.Seq.uncons tl); assert false with Stdcompat.Seq.Forced_twice -> () end; let hd'', _tl'' = Stdcompat.Option.get (Stdcompat.Seq.uncons tl') in assert (hd'' = 2) let test_seq_transpose () = let test_format m n = let s = Stdcompat.Seq.init m (fun i -> Stdcompat.Seq.init n (fun j -> i * n + j)) in let t = Stdcompat.Seq.init n (fun j -> Stdcompat.Seq.init m (fun i -> i * n + j)) in assert (Stdcompat.Seq.equal (Stdcompat.Seq.equal Stdcompat.Int.equal) (Stdcompat.Seq.transpose s) t) in test_format 3 3; test_format 3 4; test_format 4 3; let s = Stdcompat.Seq.iterate (fun i -> Stdcompat.Seq.map (( * ) 2) i) (Stdcompat.Seq.ints 0) in let t = Stdcompat.Seq.transpose s in assert (Stdcompat.Seq.equal (Stdcompat.Seq.equal Stdcompat.Int.equal) (Stdcompat.Seq.map (Stdcompat.Seq.take 3) (Stdcompat.Seq.take 3 t)) (Stdcompat.Seq.init 3 (fun i -> Stdcompat.Seq.init 3 (fun j -> i * (1 lsl j))))); let s = Stdcompat.Seq.map Stdcompat.List.to_seq (Stdcompat.List.to_seq [[0; 1]; [2; 3; 4; 5]; [6; 7; 8]]) in let t = Stdcompat.Seq.transpose s in assert (Stdcompat.List.of_seq (Stdcompat.Seq.map Stdcompat.List.of_seq t) = [[0; 2; 6]; [1; 3; 7]; [4; 8]; [5]]) let test_seq_zip () = assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.zip Stdcompat.Seq.empty (fun _ -> raise Exit))); assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.zip (Stdcompat.Seq.cons () (fun _ -> raise Exit)) Stdcompat.Seq.empty)); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.zip (Stdcompat.Seq.init 3 Stdcompat.Fun.id) (Stdcompat.Seq.init 4 (fun i -> assert (i < 4); i))) = Stdcompat.List.init 3 (fun i -> (i, i))); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 3 (Stdcompat.Seq.zip (Stdcompat.Seq.ints 0) (Stdcompat.Seq.ints 0))) = Stdcompat.List.init 3 (fun i -> (i, i))) let test_seq_map2 () = let pair i j = (i, j) in assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.map2 pair Stdcompat.Seq.empty (fun _ -> raise Exit))); assert (Stdcompat.Seq.is_empty (Stdcompat.Seq.map2 pair (Stdcompat.Seq.cons () (fun _ -> raise Exit)) Stdcompat.Seq.empty)); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.map2 pair (Stdcompat.Seq.init 3 Stdcompat.Fun.id) (Stdcompat.Seq.init 4 (fun i -> assert (i < 4); i))) = Stdcompat.List.init 3 (fun i -> (i, i))); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 3 (Stdcompat.Seq.map2 pair (Stdcompat.Seq.ints 0) (Stdcompat.Seq.ints 0))) = Stdcompat.List.init 3 (fun i -> (i, i))) let test_seq_interleave () = assert ( Stdcompat.List.of_seq (Stdcompat.Seq.interleave Stdcompat.Seq.empty (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id))) = [0; 1; 2; 3; 4; 5]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.interleave (Stdcompat.Seq.once (Stdcompat.Seq.init 6 Stdcompat.Fun.id)) Stdcompat.Seq.empty) = [0; 1; 2; 3; 4; 5]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.interleave (Stdcompat.Seq.once (Stdcompat.Seq.init 3 (fun i -> i * 2))) (Stdcompat.Seq.once (Stdcompat.Seq.init 3 (fun i -> i * 2 + 1)))) = [0; 1; 2; 3; 4; 5]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.interleave (Stdcompat.Seq.once (Stdcompat.Seq.init 5 (fun i -> i * 2))) (Stdcompat.Seq.once (Stdcompat.Seq.init 3 (fun i -> i * 2 + 1)))) = [0; 1; 2; 3; 4; 5; 6; 8]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.interleave (Stdcompat.Seq.once (Stdcompat.Seq.init 3 (fun i -> i * 2))) (Stdcompat.Seq.once (Stdcompat.Seq.init 5 (fun i -> i * 2 + 1)))) = [0; 1; 2; 3; 4; 5; 7; 9]) let test_seq_sorted_merge () = assert ( Stdcompat.List.of_seq (Stdcompat.Seq.sorted_merge (fun (i, _) (j, _) -> Stdcompat.Int.compare i j) (Stdcompat.Seq.once (Stdcompat.List.to_seq [1, false; 4, false; 6, false; 7, false])) (Stdcompat.Seq.once (Stdcompat.List.to_seq [1, true; 2, true; 4, true; 5, true]))) = [1, false; 1, true; 2, true; 4, false; 4, true; 5, true; 6, false; 7, false]); assert ( Stdcompat.List.of_seq (Stdcompat.Seq.take 8 ( Stdcompat.Seq.sorted_merge Stdcompat.Int.compare (Stdcompat.Seq.once (Stdcompat.Seq.map (fun i -> assert (i < 4); i * 3) (Stdcompat.Seq.ints 0))) (Stdcompat.Seq.once (Stdcompat.Seq.map (fun i -> assert (i < 5); 1 lsl i) (Stdcompat.Seq.ints 0))))) = [0; 1; 2; 3; 4; 6; 8; 9]) let test_seq_product () = assert (List.sort compare (Stdcompat.List.of_seq (Stdcompat.Seq.product (Stdcompat.Seq.init 3 Stdcompat.Fun.id) (Stdcompat.Seq.init 3 Stdcompat.Fun.id))) = (Stdcompat.List.init 9 (fun i -> (i / 3, i mod 3)))); assert ( List.length (Stdcompat.List.sort_uniq compare (Stdcompat.List.of_seq (Stdcompat.Seq.take 8 (Stdcompat.Seq.product (Stdcompat.Seq.ints 0) (Stdcompat.Seq.ints 0))))) = 8) let test_seq_map_product () = let pair i j = (i, j) in assert (List.sort compare ( Stdcompat.List.of_seq (Stdcompat.Seq.map_product pair (Stdcompat.Seq.init 3 Stdcompat.Fun.id) (Stdcompat.Seq.init 3 Stdcompat.Fun.id))) = (Stdcompat.List.init 9 (fun i -> (i / 3, i mod 3)))); assert ( List.length (Stdcompat.List.sort_uniq compare (Stdcompat.List.of_seq (Stdcompat.Seq.take 8 (Stdcompat.Seq.map_product pair (Stdcompat.Seq.ints 0) (Stdcompat.Seq.ints 0))))) = 8) let test_seq_unzip () = let s, s' = Stdcompat.Seq.unzip (Stdcompat.Seq.map (fun i -> (i, i)) (Stdcompat.Seq.take 6 (Stdcompat.Seq.ints 0))) in assert (Stdcompat.List.of_seq s = Stdcompat.List.init 6 Stdcompat.Fun.id); assert (Stdcompat.List.of_seq s' = Stdcompat.List.init 6 Stdcompat.Fun.id); let s, s' = Stdcompat.Seq.unzip (Stdcompat.Seq.map (fun i -> assert (i < 6); (i, i)) (Stdcompat.Seq.ints 0)) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = Stdcompat.List.init 6 Stdcompat.Fun.id); assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s') = Stdcompat.List.init 6 Stdcompat.Fun.id) let test_seq_partition_map () = let s, s' = Stdcompat.Seq.partition_map (fun i -> if i mod 3 = 0 then Stdcompat.Either.Left i else Stdcompat.Either.Right i) (Stdcompat.Seq.take 6 (Stdcompat.Seq.ints 0)) in assert (Stdcompat.List.of_seq s = [0; 3]); assert (Stdcompat.List.of_seq s' = [1; 2; 4; 5]); let s, s' = Stdcompat.Seq.partition_map (fun i -> assert (i <= 15); if i mod 3 = 0 then Stdcompat.Either.Left i else Stdcompat.Either.Right i) (Stdcompat.Seq.ints 0) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [0; 3; 6; 9; 12; 15]); assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s') = [1; 2; 4; 5; 7; 8]) let test_seq_partition () = let s, s' = Stdcompat.Seq.partition (fun i -> i mod 3 = 0) (Stdcompat.Seq.take 6 (Stdcompat.Seq.ints 0)) in assert (Stdcompat.List.of_seq s = [0; 3]); assert (Stdcompat.List.of_seq s' = [1; 2; 4; 5]); let s, s' = Stdcompat.Seq.partition (fun i -> assert (i <= 15); i mod 3 = 0) (Stdcompat.Seq.ints 0) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [0; 3; 6; 9; 12; 15]); assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s') = [1; 2; 4; 5; 7; 8]) let test_seq_of_dispenser () = let counter = ref 0 in let s = Stdcompat.Seq.of_dispenser (fun () -> let index = !counter in if index >= 6 then None else begin counter := succ index; Some index end) in assert (Stdcompat.List.of_seq s = [0; 1; 2; 3; 4; 5]); counter := 0; let s = Stdcompat.Seq.of_dispenser (fun () -> let index = !counter in counter := succ index; Some index) in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [0; 1; 2; 3; 4; 5]) let test_seq_to_dispenser () = let d = Stdcompat.Seq.to_dispenser (Stdcompat.Seq.take 6 (Stdcompat.Seq.ints 0)) in assert (d () = Some 0); assert (d () = Some 1); assert (d () = Some 2); assert (d () = Some 3); assert (d () = Some 4); assert (d () = Some 5); assert (d () = None); assert (d () = None); let d = Stdcompat.Seq.to_dispenser (Stdcompat.Seq.ints 0) in assert (d () = Some 0); assert (d () = Some 1); assert (d () = Some 2); assert (d () = Some 3); assert (d () = Some 4); assert (d () = Some 5) let test_seq_ints () = let s = Stdcompat.Seq.ints 4 in assert (Stdcompat.List.of_seq (Stdcompat.Seq.take 6 s) = [4; 5; 6; 7; 8; 9]) let test_seq_4_14 () = test_seq_is_empty (); test_seq_uncons (); test_seq_length (); test_seq_iteri (); test_seq_forall (); test_seq_exists (); test_seq_find (); test_seq_find_map (); test_seq_iter2 (); test_seq_fold_left2 (); test_seq_for_all2 (); test_seq_exists2 (); test_seq_equal (); test_seq_compare (); test_seq_init (); test_seq_repeat (); test_seq_forever (); test_seq_cycle (); test_seq_iterate (); test_seq_mapi (); test_seq_scan (); test_seq_take (); test_seq_drop (); test_seq_take_while (); test_seq_drop_while (); test_seq_group (); test_seq_memoize (); test_seq_once (); test_seq_transpose (); test_seq_zip (); test_seq_map2 (); test_seq_interleave (); test_seq_sorted_merge (); test_seq_product (); test_seq_map_product (); test_seq_unzip (); test_seq_partition_map (); test_seq_partition (); test_seq_of_dispenser (); test_seq_to_dispenser (); test_seq_ints () let test_int32_min_max () = assert (Stdcompat.Int32.min 1l 2l = 1l); assert (Stdcompat.Int32.max 1l 2l = 2l) let test_int32_unsigned_compare () = assert (Stdcompat.Int32.unsigned_compare 1l 2l < 0); assert (Stdcompat.Int32.unsigned_compare (-1l) 2l > 0) let test_array_fold_left_map () = let f counter item = succ counter, item + counter in assert (Stdcompat.Array.fold_left_map f 0 [| 1; 2; 3; 4; 5 |] = (5, [| 1; 3; 5; 7; 9 |])) let test_array_find_opt () = assert (Stdcompat.Array.find_opt (fun i -> i mod 2 = 0) [| 1; 3; 4; 5 |] = Some 4); assert (Stdcompat.Array.find_opt (fun i -> i mod 2 = 0) [| 1; 3; 5 |] = None) let test_array_find_map () = let f i = if i mod 2 = 0 then Some (i / 2) else None in assert (Stdcompat.Array.find_map f [| 1; 3; 4; 5 |] = Some 2); assert (Stdcompat.Array.find_map f [| 1; 3; 5 |] = None) let test_array_split () = assert (Stdcompat.Array.split [| |] = ([| |], [| |])); assert (Stdcompat.Array.split [| (1, 2); (3, 4) |] = ([| 1; 3 |], [| 2; 4 |])) let test_array_combine () = assert (Stdcompat.Array.combine [| |] [| |] = [| |]); assert (Stdcompat.Array.combine [| 1; 3 |] [| 2; 4 |] = [| (1, 2); (3, 4) |]) let test_string_fold_left () = let f i c = assert (int_of_char c - int_of_char '0' = i); succ i in assert (Stdcompat.String.fold_left f 0 "0123" = 4); assert (Stdcompat.String.fold_left f 0 "" = 0) let test_string_fold_right () = let f c i = assert (int_of_char c - int_of_char '0' = pred i); pred i in assert (Stdcompat.String.fold_right f "0123" 4 = 0); assert (Stdcompat.String.fold_right f "" 0 = 0) let test_string_for_all () = let f c = match c with | '0' .. '9' -> true | _ -> false in assert (Stdcompat.String.for_all f "0123" = true); assert (Stdcompat.String.for_all f "012a3" = false); assert (Stdcompat.String.for_all f "" = true) let test_string_exists () = let f c = match c with | 'a' .. 'z' -> true | _ -> false in assert (Stdcompat.String.exists f "0123" = false); assert (Stdcompat.String.exists f "012a3" = true); assert (Stdcompat.String.exists f "" = false) let test_string_starts_with () = assert (Stdcompat.String.starts_with ~prefix:"a" "abc" = true); assert (Stdcompat.String.starts_with ~prefix:"a" "bc" = false); assert (Stdcompat.String.starts_with ~prefix:"a" "a" = true); assert (Stdcompat.String.starts_with ~prefix:"a" "" = false); assert (Stdcompat.String.starts_with ~prefix:"ab" "abc" = true); assert (Stdcompat.String.starts_with ~prefix:"ab" "ab" = true); assert (Stdcompat.String.starts_with ~prefix:"ab" "bc" = false); assert (Stdcompat.String.starts_with ~prefix:"ab" "ac" = false); assert (Stdcompat.String.starts_with ~prefix:"ab" "a" = false); assert (Stdcompat.String.starts_with ~prefix:"ab" "" = false) let test_string_ends_with () = assert (Stdcompat.String.ends_with ~suffix:"a" "cba" = true); assert (Stdcompat.String.ends_with ~suffix:"a" "cb" = false); assert (Stdcompat.String.ends_with ~suffix:"a" "a" = true); assert (Stdcompat.String.ends_with ~suffix:"a" "" = false); assert (Stdcompat.String.ends_with ~suffix:"ab" "cab" = true); assert (Stdcompat.String.ends_with ~suffix:"ab" "ab" = true); assert (Stdcompat.String.ends_with ~suffix:"ab" "bc" = false); assert (Stdcompat.String.ends_with ~suffix:"ab" "cb" = false); assert (Stdcompat.String.ends_with ~suffix:"ab" "b" = false); assert (Stdcompat.String.ends_with ~suffix:"ab" "" = false) let test_channels () = Stdcompat.Out_channel.with_open_text "testfile" (fun oc -> Stdcompat.Out_channel.output_substring oc "hello, world" 7 5); assert (Stdcompat.In_channel.with_open_text "testfile" Stdcompat.In_channel.input_all = "world"); Sys.remove "testfile" let tests () = testing "hypot" (fun () -> assert (Stdcompat.hypot 3. 4. = 5.); assert (Stdcompat.copysign 1. 2. = 1.); assert (Stdcompat.copysign 1. (-. 2.) = -. 1.); assert (Stdcompat.copysign (-. 1.) 2. = 1.); assert (Stdcompat.copysign (-. 1.) (-. 2.) = -. 1.); ); assert ( try ignore (Stdcompat.raise_notrace Exit); false with Exit -> true); testing "bool_of_string_opt" (fun () -> assert (Stdcompat.bool_of_string_opt "true" = Some true); assert (Stdcompat.bool_of_string_opt "false" = Some false); assert (Stdcompat.bool_of_string_opt "foo" = None)); testing "int_of_string_opt" (fun () -> assert (Stdcompat.int_of_string_opt "42" = Some 42); assert (Stdcompat.int_of_string_opt "foo" = None)); assert (Stdcompat.float_of_string_opt "42." = Some 42.); assert (Stdcompat.float_of_string_opt "foo" = None); assert (Lazy.force (Stdcompat.Lazy.from_fun (fun () -> 42)) = 42); assert (Lazy.force (Stdcompat.Lazy.from_val 42) = 42); assert (Stdcompat.Char.lowercase_ascii 'A' = 'a'); assert (Stdcompat.Char.uppercase_ascii 'a' = 'A'); assert (Stdcompat.Char.equal 'a' 'a'); assert (not (Stdcompat.Char.equal 'A' 'a')); assert (Stdcompat.String.init 2 (fun i -> char_of_int i) = "\000\001"); assert (Stdcompat.String.mapi (fun i c -> char_of_int (i + int_of_char c)) "abc" = "ace"); assert ( let s = Stdcompat.Bytes.create 3 in Stdcompat.String.iteri (fun i c -> Stdcompat.Bytes.set s i c) "abc"; s = Stdcompat.Bytes.of_string "abc"); assert (Stdcompat.String.map Stdcompat.Char.uppercase_ascii "abc" = "ABC"); assert (Stdcompat.String.trim " \t abc\n" = "abc"); assert (Stdcompat.String.lowercase_ascii "AbcD" = "abcd"); assert (Stdcompat.String.uppercase_ascii "AbcD" = "ABCD"); assert (Stdcompat.String.capitalize_ascii "abcD" = "AbcD"); assert (Stdcompat.String.uncapitalize_ascii "AbcD" = "abcD"); assert (Stdcompat.String.equal "abc" "abc"); assert (not (Stdcompat.String.equal "Abc" "abc")); assert (Stdcompat.String.split_on_char ' ' " abc d ef " = ["";"abc";"";"d";"ef";"";""]); assert (Stdcompat.String.index_opt "abaababa" 'a' = Some 0); assert (Stdcompat.String.index_opt "abaababa" 'c' = None); assert (Stdcompat.String.rindex_opt "abaababa" 'a' = Some 7); assert (Stdcompat.String.rindex_opt "abaababa" 'c' = None); assert (Stdcompat.String.index_from_opt "abaababa" 1 'a' = Some 2); assert (Stdcompat.String.index_from_opt "abaababa" 1 'c' = None); assert (Stdcompat.String.rindex_from_opt "abaababa" 4 'a' = Some 3); assert (Stdcompat.String.rindex_from_opt "abaababa" 4 'c' = None); assert ( let s = Stack.create () in Stack.push 1 s; Stack.push 2 s; Stack.push 3 s; Stdcompat.Stack.fold ( + ) 0 s = 6 && Stack.length s = 3); assert ( let t = Hashtbl.create 17 in Hashtbl.add t 1 2; Hashtbl.add t 3 4; (Stdcompat.Hashtbl.stats t).Stdcompat.Hashtbl.num_bindings = 2); assert ( let t = Hashtbl.create 17 in Hashtbl.add t 1 1; Hashtbl.add t 2 2; Hashtbl.add t 2 3; Hashtbl.add t 3 4; Stdcompat.Hashtbl.filter_map_inplace (fun k v -> if k = 3 then None else Some (pred v)) t; Hashtbl.find_all t 1 = [0] && Hashtbl.find_all t 2 = [2; 1] && Hashtbl.find_all t 3 = []); assert ( let t = Hashtbl.create 17 in Hashtbl.add t 1 1; Hashtbl.add t 2 2; Stdcompat.Hashtbl.find_opt t 1 = Some 1 && Stdcompat.Hashtbl.find_opt t 3 = None); assert ( let module H = struct type t = int let equal : int -> int -> bool = ( = ) let hash : int -> int = fun x -> x end in let module M = Hashtbl.Make (H) in let module M' = Stdcompat.Hashtbl.Make (H) in let t = M.create 17 in M.add t 1 1; M.add t 2 2; M'.find_opt t 1 = Some 1 && M'.find_opt t 3 = None); assert ( let module S = Set.Make (String) in let module S' = Stdcompat.Set.Make (String) in let s = S'.of_list ["a"; "b"; "c"] in S.compare (S'.map (fun s -> s ^ ".") s) (S'.of_list ["a."; "b."; "c."]) = 0 && S'.find_opt "a" s = Some "a" && S'.find_opt "d" s = None && S'.find_first (fun s -> s >= "b") s = "b" && S'.find_last (fun s -> s <= "b") s = "b"); assert ( let module M = Map.Make (String) in let module M' = Stdcompat.Map.Make (String) in let m = M.add "1" 2 M.empty in M'.compare compare ( M'.update "1" (function None -> Some 0 | Some i -> Some (i + 1)) (M'.update "2" (function None -> Some 0 | Some _ -> None) (M'.update "3" (function None -> None | Some i -> Some i) m))) (M.add "1" 3 (M.add "2" 0 M.empty)) = 0); assert ( let b = Stdcompat.Bytes.of_string "hello" in let b = Stdcompat.Bytes.extend b (-1) 2 in Stdcompat.Bytes.sub_string b 0 4 = "ello" && Stdcompat.Bytes.length b = 6); assert ( let l = ref [] in let f a b = l := (a, b) :: !l in Stdcompat.List.iteri f [1; 2; 3]; !l = [2, 3; 1, 2; 0, 1]); assert ( let f a b = (a, b) in Stdcompat.List.mapi f [1; 2; 3] = [0, 1; 1, 2; 2, 3]); assert ( Stdcompat.List.sort_uniq compare [2; 1; 3; 2; 1; 3] = [1; 2; 3]); assert (Stdcompat.List.cons 1 [2; 3] = [1; 2; 3]); assert (Stdcompat.List.compare_lengths [1] [2; 3] < 0); assert (Stdcompat.List.compare_lengths [1; 2] [2; 3] = 0); assert (Stdcompat.List.compare_lengths [1; 2; 3] [2; 3] > 0); assert (Stdcompat.List.compare_length_with [1] 2 < 0); assert (Stdcompat.List.compare_length_with [1; 2] 2 = 0); assert (Stdcompat.List.compare_length_with [1; 2; 3] 2 > 0); assert (Stdcompat.List.nth_opt [1; 2; 3] 2 = Some 3); assert (Stdcompat.List.nth_opt [1; 2; 3] 3 = None); assert ( try ignore (Stdcompat.List.nth_opt [1; 2; 3] (-1)); false with Invalid_argument _ -> true); assert (Stdcompat.List.find_opt (fun i -> i mod 2 = 0) [1; 2; 3] = Some 2); assert (Stdcompat.List.find_opt (fun i -> i mod 4 = 0) [1; 2; 3] = None); assert (Stdcompat.List.assoc_opt 2 [1, 0; 2, 1; 3, 2] = Some 1); assert (Stdcompat.List.assoc_opt 4 [1, 0; 2, 1; 3, 2] = None); assert (Stdcompat.List.assq_opt 2 [1, 0; 2, 1; 3, 2] = Some 1); assert ("a" == "a" || (* "a" == "a" since OCaml 4.10.0 *) Stdcompat.List.assq_opt "a" ["a", 1; "b", 2; "c", 3] = None); assert ( let r1 = ref 1 in let r1' = ref 1 in let r2 = ref 2 in let r3 = ref 3 in Stdcompat.List.assoc_opt r1' [r1, 1; r2, 2; r3, 3] = Some 1 && Stdcompat.List.assq_opt r1' [r1, 1; r2, 2; r3, 3] = None); assert (Stdcompat.Filename.extension "a.b/c.de" = ".de"); assert (Stdcompat.Filename.extension "a.b/cd" = ""); assert (Stdcompat.Filename.remove_extension "a.b/c.de" = "a.b/c"); assert (Stdcompat.Filename.remove_extension "a.b/cd" = "a.b/cd"); @BEGIN_WITH_UNIX@ assert (Stdcompat.Filename.remove_extension "a.b\\cd" = "a"); @END_WITH_UNIX@ @BEGIN_WITHOUT_UNIX@ assert (Stdcompat.Filename.remove_extension "a.b\\cd" = "a.b\\cd"); @END_WITHOUT_UNIX@ assert ( let array = Stdcompat.Array.Floatarray.create 2 in Stdcompat.Array.Floatarray.set array 0 1.; Stdcompat.Array.Floatarray.set array 1 2.; Stdcompat.Array.Floatarray.get array 0 = 1. && Stdcompat.Array.Floatarray.get array 1 = 2.); assert ( let l = ref [] in let f a b = l := (a, b) :: !l in Stdcompat.Array.iter2 f [| 0; 1 |] [| 2; 3 |]; !l = [1, 3; 0, 2]); assert ( let f a b = (a, b) in Stdcompat.Array.map2 f [| 0; 1 |] [| 2; 3 |] = [| 0, 2; 1, 3 |]); assert (Stdcompat.Array.for_all (fun x -> x > 0) [| 1; 2; 3 |]); assert (not (Stdcompat.Array.for_all (fun x -> x > 0) [| 1; 2; 0; 3 |])); assert (Stdcompat.Array.exists (fun x -> x > 2) [| 1; 2; 3 |]); assert (not (Stdcompat.Array.exists (fun x -> x > 3) [| 1; 2; 3 |])); assert (Stdcompat.Array.mem "a" [| "a"; "b"; "c" |]); assert (not (Stdcompat.Array.mem "d" [| "a"; "b"; "c" |])); assert (Stdcompat.Array.memq 2 [| 1; 2; 3 |]); assert ("a" == "a" || (* "a" == "a" since OCaml 4.10.0 *) not (Stdcompat.Array.memq "a" [| "a"; "b"; "c" |])); assert ( let r1 = ref 1 in let r1' = ref 1 in let r2 = ref 2 in let r3 = ref 3 in Stdcompat.List.mem r1' [r1; r2; r3] && not (Stdcompat.List.memq r1' [r1; r2; r3])); assert ( let q = Stdcompat.Queue.create () in Stdcompat.Array.of_seq (Stdcompat.Queue.to_seq q) = [| |]); assert ( let q = Stdcompat.Queue.create () in Stdcompat.Queue.add_seq q (Stdcompat.List.to_seq ["a"; "b"; "c"]); Stdcompat.Array.of_seq (Stdcompat.Queue.to_seq q) = [| "a"; "b"; "c" |]); assert ( let l = Stdcompat.List.to_seq ["a", 1; "b", 2; "c", 3] in let module M = Stdcompat.Map.Make (String) in let q = Stdcompat.Hashtbl.of_seq (M.to_seq (M.of_seq l)) in let m = M.of_seq (Stdcompat.Hashtbl.to_seq q) in M.cardinal m = 3 && M.find "a" m = 1 && M.find "b" m = 2 && M.find "c" m = 3); assert ( Stdcompat.Filename.chop_suffix_opt ~suffix:".txt" "readme.txt" = Some "readme"); assert ( Stdcompat.Filename.chop_suffix_opt ~suffix:".txt" "x" = None); assert ( Stdcompat.Filename.chop_suffix_opt ~suffix:".txt" "readme.md" = None); @BEGIN_WITH_WIN32@ assert ( Stdcompat.Filename.chop_suffix_opt ~suffix:".txt" "readme.TXT" = Some "readme"); @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ assert ( Stdcompat.Filename.chop_suffix_opt ~suffix:".txt" "readme.TXT" = None); @END_WITHOUT_WIN32@ assert (Stdcompat.Filename.chop_suffix "readme.txt" ".txt" = "readme"); begin try ignore (Stdcompat.Filename.chop_suffix "x" ".txt"); assert false with Invalid_argument _ -> () end; begin try ignore (Stdcompat.Filename.chop_suffix "readme.md" ".txt"); assert false with Invalid_argument _ -> () end; @BEGIN_WITH_WIN32@ assert (Stdcompat.Filename.chop_suffix "readme.TXT" ".txt" = "readme"); @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ begin try ignore (Stdcompat.Filename.chop_suffix "readme.TXT" ".txt"); assert false with Invalid_argument _ -> () end; @END_WITHOUT_WIN32@ @BEGIN_WITH_WIN32@ assert (Stdcompat.Filename.dir_sep = "\\"); @END_WITH_WIN32@ @BEGIN_WITHOUT_WIN32@ assert (Stdcompat.Filename.dir_sep = "/"); @END_WITHOUT_WIN32@ assert (not (Stdcompat.Float.sign_bit 1.)); assert (not (Stdcompat.Float.sign_bit 0.)); assert (not (Stdcompat.Float.is_nan 42.)); assert (Stdcompat.Float.is_nan (0. /. 0.)); assert (not (Stdcompat.Float.is_infinite 0.)); assert (Stdcompat.Float.is_infinite (1. /. 0.)); assert (not (Stdcompat.Float.is_infinite (0. /. 0.))); assert (Stdcompat.Float.is_finite 0.); assert (not (Stdcompat.Float.is_finite (1. /. 0.))); assert (not (Stdcompat.Float.is_finite (0. /. 0.))); assert (Stdcompat.Float.trunc 1.5 = 1.); assert (Stdcompat.Float.trunc (-2.6) = -2.); assert (Stdcompat.Float.is_infinite (Stdcompat.Float.trunc (1. /. 0.))); assert (Stdcompat.Float.is_nan (Stdcompat.Float.trunc (0. /. 0.))); assert (Stdcompat.Float.is_integer 1.); assert (not (Stdcompat.Float.is_integer 1.5)); assert (Stdcompat.Float.is_infinite (Stdcompat.Float.trunc (1. /. 0.))); assert (Stdcompat.Float.is_nan (Stdcompat.Float.trunc (0. /. 0.))); assert (Stdcompat.Float.round 1.5 = 2.); assert (Stdcompat.Float.round 1.4 = 1.); assert (Stdcompat.Float.round (-2.6) = -3.); assert (Stdcompat.Float.round (-3.5) = -4.); assert (Stdcompat.Float.round (-4.4) = -4.); assert (Stdcompat.Float.is_infinite (Stdcompat.Float.round (1. /. 0.))); assert (Stdcompat.Float.is_nan (Stdcompat.Float.round (0. /. 0.))); assert (Stdcompat.Float.sign_bit (-1.)); assert (Stdcompat.Float.min_num 1. (0. /. 0.) = 1.); assert (Stdcompat.Float.min_num (0. /. 0.) 1. = 1.); assert (Stdcompat.Float.min_num 1. (-1.) = (-1.)); assert (Stdcompat.Float.min_num (-1.) 1. = (-1.)); assert (Stdcompat.Float.sign_bit (Stdcompat.Float.min_num 0. (-0.))); assert (Stdcompat.Float.sign_bit (Stdcompat.Float.min_num (-0.) 0.)); assert (Stdcompat.Float.is_nan ( Stdcompat.Float.min_num (0. /. 0.) (0. /. 0.))); assert (Stdcompat.Float.max_num 1. (0. /. 0.) = 1.); assert (Stdcompat.Float.max_num (0. /. 0.) 1. = 1.); assert (Stdcompat.Float.max_num 1. (-1.) = 1.); assert (Stdcompat.Float.max_num (-1.) 1. = 1.); assert (not (Stdcompat.Float.sign_bit (Stdcompat.Float.max_num 0. (-0.)))); assert (not (Stdcompat.Float.sign_bit (Stdcompat.Float.max_num (-0.) 0.))); assert (Stdcompat.Float.is_nan ( Stdcompat.Float.max_num (0. /. 0.) (0. /. 0.))); assert (Stdcompat.Float.min_max_num 1. (0. /. 0.) = (1., 1.)); assert (Stdcompat.Float.min_max_num (0. /. 0.) 1. = (1., 1.)); assert (Stdcompat.Float.min_max_num 1. (-1.) = (-1., 1.)); assert (Stdcompat.Float.min_max_num (-1.) 1. = (-1., 1.)); assert ( let min, max = Stdcompat.Float.min_max_num 0. (-0.) in Stdcompat.Float.sign_bit min && not (Stdcompat.Float.sign_bit max)); assert ( let min, max = Stdcompat.Float.min_max_num (-0.) 0. in Stdcompat.Float.sign_bit min && not (Stdcompat.Float.sign_bit max)); assert ( let min, max = Stdcompat.Float.min_max_num (0. /. 0.) (0. /. 0.) in Stdcompat.Float.is_nan min && Stdcompat.Float.is_nan max); assert (Stdcompat.Float.is_nan (Stdcompat.Float.min 1. (0. /. 0.))); assert (Stdcompat.Float.is_nan (Stdcompat.Float.min (0. /. 0.) 1.)); assert (Stdcompat.Float.min 1. (-1.) = (-1.)); assert (Stdcompat.Float.min (-1.) 1. = (-1.)); assert (Stdcompat.Float.sign_bit (Stdcompat.Float.min 0. (-0.))); assert (Stdcompat.Float.sign_bit (Stdcompat.Float.min (-0.) 0.)); assert (Stdcompat.Float.is_nan ( Stdcompat.Float.min (0. /. 0.) (0. /. 0.))); assert (Stdcompat.Float.is_nan (Stdcompat.Float.max 1. (0. /. 0.))); assert (Stdcompat.Float.is_nan (Stdcompat.Float.max (0. /. 0.) 1.)); assert (Stdcompat.Float.max 1. (-1.) = 1.); assert (Stdcompat.Float.max (-1.) 1. = 1.); assert (not (Stdcompat.Float.sign_bit (Stdcompat.Float.max 0. (-0.)))); assert (not (Stdcompat.Float.sign_bit (Stdcompat.Float.max (-0.) 0.))); assert (Stdcompat.Float.is_nan ( Stdcompat.Float.max (0. /. 0.) (0. /. 0.))); assert ( let min, max = Stdcompat.Float.min_max 1. (0. /. 0.) in Stdcompat.Float.is_nan min && Stdcompat.Float.is_nan max); assert ( let min, max = Stdcompat.Float.min_max (0. /. 0.) 1. in Stdcompat.Float.is_nan min && Stdcompat.Float.is_nan max); assert (Stdcompat.Float.min_max 1. (-1.) = (-1., 1.)); assert (Stdcompat.Float.min_max (-1.) 1. = (-1., 1.)); assert ( let min, max = Stdcompat.Float.min_max 0. (-0.) in Stdcompat.Float.sign_bit min && not (Stdcompat.Float.sign_bit max)); assert ( let min, max = Stdcompat.Float.min_max (-0.) 0. in Stdcompat.Float.sign_bit min && not (Stdcompat.Float.sign_bit max)); assert ( let min, max = Stdcompat.Float.min_max (0. /. 0.) (0. /. 0.) in Stdcompat.Float.is_nan min && Stdcompat.Float.is_nan max); assert (Stdcompat.Float.next_after max_float infinity = infinity); assert (Stdcompat.Float.next_after 0. infinity = Int64.float_of_bits Stdcompat.Int64.one); assert (Stdcompat.Float.next_after (Int64.float_of_bits Stdcompat.Int64.one) 0. = 0.); assert (Stdcompat.Float.next_after 1. 1. = 1.); assert (Stdcompat.Float.is_nan (Stdcompat.Float.next_after (0. /. 0.) 1.)); assert (Stdcompat.Float.is_nan (Stdcompat.Float.next_after 1. (0. /. 0.))); let b = Stdcompat.Bytes.of_string "\x20\x30\x40\x50\x60\x70\x80\x90" in assert (Stdcompat.Bytes.get_uint8 b 1 = 0x30); assert (Stdcompat.Bytes.get_int8 b 1 = 0x30); assert (Stdcompat.Bytes.get_uint8 b 6 = 0x80); assert (Stdcompat.Bytes.get_int8 b 6 = -0x80); assert (Stdcompat.Bytes.get_uint16_le b 4 = 0x7060); assert (Stdcompat.Bytes.get_uint16_be b 4 = 0x6070); assert (Stdcompat.Bytes.get_int16_le b 4 = 0x7060); assert (Stdcompat.Bytes.get_int16_be b 4 = 0x6070); assert (Stdcompat.Bytes.get_uint16_le b 6 = 0x9080); assert (Stdcompat.Bytes.get_uint16_be b 6 = 0x8090); assert (Stdcompat.Bytes.get_int16_le b 6 = -0x6F80); assert (Stdcompat.Bytes.get_int16_be b 6 = -0x7F70); assert (Stdcompat.Bytes.get_int32_le b 0 = 0x50403020l); assert (Stdcompat.Bytes.get_int32_be b 0 = 0x20304050l); assert (Stdcompat.Bytes.get_int64_le b 0 = 0x9080706050403020L); assert (Stdcompat.Bytes.get_int64_be b 0 = 0x2030405060708090L); let check_invalid_arg f = try let _ = f () in false with Invalid_argument _ -> true in assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_uint8 b (-1))); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_uint8 b 8)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_uint16_le b (-1))); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_uint16_le b 7)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_int32_le b (-1))); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_int32_le b 5)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_int64_le b (-1))); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.get_int64_le b 1)); assert ( Stdcompat.Bytes.set_uint8 b 1 0x90; Stdcompat.Bytes.get_uint8 b 1 = 0x90); assert ( Stdcompat.Bytes.set_int8 b 1 (-0x20); Stdcompat.Bytes.get_int8 b 1 = (-0x20)); assert ( Stdcompat.Bytes.set_uint16_le b 1 0x1234; Stdcompat.Bytes.get_uint16_le b 1 = 0x1234); assert ( Stdcompat.Bytes.set_uint16_be b 1 0x1234; Stdcompat.Bytes.get_uint16_be b 1 = 0x1234); assert ( Stdcompat.Bytes.set_int16_le b 1 (-0x1234); Stdcompat.Bytes.get_int16_le b 1 = (-0x1234)); assert ( Stdcompat.Bytes.set_int16_be b 1 (-0x1234); Stdcompat.Bytes.get_int16_be b 1 = (-0x1234)); assert ( Stdcompat.Bytes.set_int32_le b 1 0x12345678l; Stdcompat.Bytes.get_int32_le b 1 = 0x12345678l); assert ( Stdcompat.Bytes.set_int32_be b 1 0x12345678l; Stdcompat.Bytes.get_int32_be b 1 = 0x12345678l); assert ( Stdcompat.Bytes.set_int64_le b 0 0x123456789ABCDEF0L; Stdcompat.Bytes.get_int64_le b 0 = 0x123456789ABCDEF0L); assert ( Stdcompat.Bytes.set_int64_be b 0 0x123456789ABCDEF0L; Stdcompat.Bytes.get_int64_be b 0 = 0x123456789ABCDEF0L); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_uint8 b (-1) 0)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_uint8 b 8 0)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_uint16_le b (-1) 0)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_uint16_le b 7 0)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_int32_le b (-1) 0l)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_int32_le b 5 0l)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_int64_le b (-1) 0L)); assert (check_invalid_arg (fun () -> Stdcompat.Bytes.set_int64_le b 1 0L)); assert (Stdcompat.Bytes.get_int64_be b 0 = 0x123456789ABCDEF0L); assert ( let finalized = ref false in Stdcompat.Fun.protect ~finally:(fun () -> finalized := true) (fun () -> true) && !finalized); assert ( try Stdcompat.Fun.protect ~finally:(fun () -> raise Exit) (fun () -> failwith "protect") with Stdcompat.Fun.Finally_raised Exit -> true | _ -> false); let (_ : 'a Stdcompat.Seq.t) = Stdcompat.Stdlib.Seq.empty in let (_ : 'a Stdcompat.Stdlib.Seq.t) = Stdcompat.Seq.empty in let (_ : (unit, 'a) Stdcompat.result) = Stdcompat.Ok () in let (_ : (unit, 'a) Stdcompat.Result.t) = Stdcompat.Ok () in let (_ : (unit, 'a) Stdcompat.Stdlib.Result.t) = Stdcompat.Ok () in let (_ : (unit, 'a) Stdcompat.result) = Stdcompat.Result.Ok () in let (_ : (unit, 'a) Stdcompat.Result.t) = Stdcompat.Result.Ok () in let (_ : (unit, 'a) Stdcompat.Stdlib.Result.t) = Stdcompat.Result.Ok () in let (_ : (unit, 'a) Stdcompat.result) = Stdcompat.Stdlib.Result.Ok () in let (_ : (unit, 'a) Stdcompat.Result.t) = Stdcompat.Stdlib.Result.Ok () in let (_ : (unit, 'a) Stdcompat.Stdlib.Result.t) = Stdcompat.Stdlib.Result.Ok () in assert (Stdcompat.Fun.id true); assert (Stdcompat.Fun.const true false); assert (Stdcompat.Fun.flip ( - ) 1 2 = 1); assert (Stdcompat.Fun.negate not true); assert ( let bytes = Stdcompat.Bytes.of_string "abcde" in Stdcompat.Bytes.unsafe_blit_string "ABCDEF" 2 bytes 1 3; Stdcompat.Bytes.compare bytes (Stdcompat.Bytes.of_string "aCDEe") == 0); assert ( Stdcompat.List.concat_map (fun x -> [x * 2; x - 1]) [1; 2; 3] = [2; 0; 4; 1; 6; 2]); assert ( Stdcompat.List.find_map (Stdcompat.List.assoc_opt 1) [[2, 3; 4, 1]; [5, 2;1, 7]] = Some 7); assert ( Stdcompat.List.find_map (Stdcompat.List.assoc_opt 1) [[2, 3; 4, 1]; [5, 2;2, 7]] = None); testing "Filename.quote_command" (fun () -> let check_quote_string s = let (file, channel) = Filename.open_temp_file "test_quote_command" ".ml" in Stdcompat.Fun.protect (fun () -> Stdcompat.Fun.protect (fun () -> Printf.fprintf channel " assert (Sys.argv.(1) = \"%s\") " (String.escaped s)) ~finally:(fun () -> close_out channel); let file_exe = Filename.chop_suffix file ".ml" ^ ".exe" in assert ( Sys.command (Stdcompat.Filename.quote_command "ocamlopt.opt" [file; "-o"; file_exe]) == 0); assert ( Sys.command (Stdcompat.Filename.quote_command file_exe [s]) == 0)) ~finally:(fun () -> Sys.remove file) in check_quote_string "a\\\\"; check_quote_string "a\\\\b\"\\\"\\\\\"\"\\"; ); test_array_for_all2 (); test_array_exists2 (); test_list_filteri (); test_list_fold_left_map (); test_seq_cons (); test_seq_append (); test_seq_unfold (); testing "Seq (new functions introduced in OCaml 4.14)" test_seq_4_14; testing "Set.filter_map" test_set_filter_map; testing "Map.filter_map" test_map_filter_map; testing "Sys.mkdir/Sys.rmdir" test_mkdir_rmdir; testing "Set.to_seq/to_rev_seq" test_set_to_seq_to_rev_seq; testing "Map.to_seq/to_rev_seq" test_map_to_seq_to_rev_seq; test_list_partition_map (); test_list_compare (); test_list_equal (); test_hashtbl_rebuild (); test_format_pp_print_seq (); test_either (); test_seq_concat (); test_int32_min_max (); test_int32_unsigned_compare (); test_array_fold_left_map (); test_array_find_opt (); test_array_find_map (); test_array_split (); test_array_combine (); test_string_fold_left (); test_string_fold_right (); test_string_for_all (); test_string_exists (); test_string_starts_with (); test_string_ends_with (); test_channels (); () let () = tests (); if !failed then exit 1 ocaml-stdcompat-20~git20240529/test_all_switches.sh000077500000000000000000000004031463722102200221710ustar00rootroot00000000000000#!/usr/bin/env bash set -e for ocamlversion in `opam switch -i -s`; do opam switch $ocamlversion eval `opam config env` ./configure make clean make make tests ./configure --disable-magic make clean make make tests done