pax_global_header00006660000000000000000000000064150513023040014503gustar00rootroot0000000000000052 comment=c7e6dda451f5f145d439d5243e8b2eef4597f94b stdcompat-21.1/000077500000000000000000000000001505130230400134245ustar00rootroot00000000000000stdcompat-21.1/.gitattributes000066400000000000000000000002251505130230400163160ustar00rootroot00000000000000ci/*.sh -text .github/scripts/*.sh text eol=lf /_generated-files text eol=lf /configure text eol=lf /Makefile.in text eol=lf /install-sh text eol=lf stdcompat-21.1/.github/000077500000000000000000000000001505130230400147645ustar00rootroot00000000000000stdcompat-21.1/.github/scripts/000077500000000000000000000000001505130230400164535ustar00rootroot00000000000000stdcompat-21.1/.github/scripts/build-dune.sh000077500000000000000000000001171505130230400210410ustar00rootroot00000000000000set -e opam install --yes dune dune build --ignore-promoted-rules dune runtest stdcompat-21.1/.github/scripts/build-in-docker.sh000077500000000000000000000002071505130230400217610ustar00rootroot00000000000000set -e ocaml_compiler="$1" builder="$2" opam switch "$ocaml_compiler" eval $(opam env) sh -exc ".github/scripts/build-\"$builder\".sh" stdcompat-21.1/.github/scripts/build-make-no-magic.sh000077500000000000000000000000621505130230400225120ustar00rootroot00000000000000set -e ./configure --disable-magic make make test stdcompat-21.1/.github/scripts/build-make.sh000077500000000000000000000000421505130230400210200ustar00rootroot00000000000000set -e ./configure make make test stdcompat-21.1/.github/scripts/check-generated-files.sh000077500000000000000000000004661505130230400231310ustar00rootroot00000000000000set -e opam install --yes dune dune build ./configure git config user.email stdcompat-ci@nodomain.org git config user.name stdcompat-ci git add -f `cat _generated-files` git commit -m "Generated files as produced by configure" (while read f; do mv _build/default/$f .; done) < _generated-files git diff stdcompat-21.1/.github/workflows/000077500000000000000000000000001505130230400170215ustar00rootroot00000000000000stdcompat-21.1/.github/workflows/check-generated-files.yml000066400000000000000000000024701505130230400236600ustar00rootroot00000000000000name: check-generated-files on: push: branches: - 'main' pull_request: types: [opened, synchronize, reopened, labeled, unlabeled] jobs: build-ubuntu: strategy: fail-fast: false matrix: ocaml-compiler: - 4.11.x - 4.12.x - 4.13.x - 4.14.x - 5.0.x - 5.1.x - 5.2.x - 5.3.x runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Setup OCaml uses: ocaml/setup-ocaml@v3 with: ocaml-compiler: ${{ matrix.ocaml-compiler }} - name: Check generated files run: | opam exec -- sh -xc ".github/scripts/check-generated-files.sh" build-macos-and-windows: strategy: fail-fast: false matrix: os: - macos-latest - windows-latest ocaml-compiler: - 4.14.x - 5.0.x - 5.1.x - 5.2.x runs-on: ${{ matrix.os }} steps: - name: Checkout uses: actions/checkout@v4 - name: Setup OCaml uses: ocaml/setup-ocaml@v3 with: ocaml-compiler: ${{ matrix.ocaml-compiler }} - name: Verify generated files run: | opam exec -- sh -xc ".github/scripts/check-generated-files.sh" stdcompat-21.1/.github/workflows/main.yml000066400000000000000000000041661505130230400204770ustar00rootroot00000000000000name: main on: push: branches: - 'main' pull_request: types: [opened, synchronize, reopened, labeled, unlabeled] jobs: build-ubuntu: strategy: fail-fast: false matrix: builder: - dune - make - make-no-magic ocaml-compiler: - 4.11.x - 4.12.x - 4.13.x - 4.14.x - 5.0.x - 5.1.x - 5.2.x - 5.3.x runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Setup OCaml uses: ocaml/setup-ocaml@v3 with: ocaml-compiler: ${{ matrix.ocaml-compiler }} - name: Make stdcompat run: | opam exec -- sh -xc ".github/scripts/build-${{ matrix.builder }}.sh" build-macos-and-windows: strategy: fail-fast: false matrix: os: - macos-latest - windows-latest builder: - dune - make - make-no-magic ocaml-compiler: - 4.14.x - 5.0.x - 5.1.x - 5.2.x - 5.3.x runs-on: ${{ matrix.os }} steps: - name: Checkout uses: actions/checkout@v4 - name: Setup OCaml uses: ocaml/setup-ocaml@v3 with: ocaml-compiler: ${{ matrix.ocaml-compiler }} - name: Make stdcompat run: | opam exec -- sh -xc ".github/scripts/build-${{ matrix.builder }}.sh" # build-ubuntu-ocaml-5-beta: # strategy: # fail-fast: false # matrix: # builder: # - dune # - make # - make-no-magic # runs-on: ubuntu-latest # container: # image: ghcr.io/thierry-martinez/stdcompat-ocaml-5-beta # credentials: # username: ${{ github.actor }} # password: ${{ secrets.packages_actions_read }} # steps: # - name: Checkout # uses: actions/checkout@v3 # - name: Make stdcompat # run: | # chown -R ci $PWD && \ # su ci -c "sh -xc \".github/scripts/build-in-docker.sh \ # 5.0.0~alpha1 \ # \\\"${{ matrix.builder }}\\\"\"" stdcompat-21.1/.github/workflows/windows.yml.disabled000066400000000000000000000014461505130230400230110ustar00rootroot00000000000000name: windows on: [push] jobs: build-windows: runs-on: windows-latest steps: - name: Setup Cygwin and mingw64 run: | choco install cygwin # patch is needed for opam choco install --source cygwin rsync patch diffutils curl make unzip git m4 perl mingw64-x86_64-gcc-core mingw64-x86_64-gcc-g++ - name: Setup opam run: | $env:PATH = 'C:\tools\cygwin\usr\local\bin;C:\tools\cygwin\bin;' + $env:PATH curl -o opam64.tar.xz -L https://github.com/fdopen/opam-repository-mingw/releases/download/0.0.0.2/opam64.tar.xz tar -xf opam64.tar.xz bash opam64/install.sh opam init default "https://github.com/fdopen/opam-repository-mingw.git#opam2" -c "ocaml-variants.4.14.0+mingw64c" --disable-sandboxing stdcompat-21.1/.gitignore000066400000000000000000000007671505130230400154260ustar00rootroot00000000000000_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 /tools/interface_dumper /tools/interface_generator /tools/.depend /stdcompat.ml /stdcompat.mli /config.guess /config.log /config.status /config.sub /stamp-h1 *.so /stdcompat__stubs.c /stdcompat_tests /tools/stdcompatpp.ml /tools/stdcompatpp /tools/stdcompatpp.opt stdcompat-21.1/AUTHORS000066400000000000000000000000541505130230400144730ustar00rootroot00000000000000Thierry Martinez stdcompat-21.1/CHANGES.md000066400000000000000000000213241505130230400150200ustar00rootroot00000000000000# 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/ocamllibs/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/ocamllibs/stdcompat/pull/16, https://github.com/ocamllibs/stdcompat/pull/19 with contribution from Kate, https://github.com/ocamllibs/stdcompat/pull/21 ) - Add support for `flambda2` (Guillaume Bury, https://github.com/ocamllibs/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/ocamllibs/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/ocamllibs/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/ocamllibs/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/ocamllibs/stdcompat/pull/2) - Compatibility with seq and result packages (suggested by Hezekiah M. Carty: https://github.com/ocamllibs/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 stdcompat-21.1/COPYING000066400000000000000000000656101505130230400144670ustar00rootroot00000000000000Copyright (c) 2017-2025, Thierry Martinez, Inria and 2025, Sébastien Hinderer, Inria. The stdcompat library is distributed under the terms of the GNU Lesser General Public License (LGPL) version 2.1 (included below). ---------------------------------------------------------------------- GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. one line to give the library's name and an idea of what it does. Copyright (C) year name of author This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. signature of Ty Coon, 1 April 1990 Ty Coon, President of Vice That's all there is to it! -------------------------------------------------- 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. stdcompat-21.1/Dockerfile000066400000000000000000000033311505130230400154160ustar00rootroot00000000000000FROM 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 stdcompat-21.1/INSTALL000066400000000000000000000366141505130230400144670ustar00rootroot00000000000000Installation 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. stdcompat-21.1/META.in000066400000000000000000000003441505130230400145030ustar00rootroot00000000000000description = "Stdcompat: compatibility module for OCaml standard library" version = "@VERSION@" archive(byte) = "stdcompat.cma" archive(native) = "stdcompat.cmxa" plugin(byte) = "stdcompat.cma" plugin(native) = "@SHARED_LIBS@" stdcompat-21.1/Makefile.am000066400000000000000000000162451505130230400154700ustar00rootroot00000000000000mypkgdir=$(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 autogen VERSION \ stdcompat__dynarray.mli 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__dynarray_s.ml stdcompat__dynarray.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 OBJEXT := @OBJEXT@ # 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/ocamllibs/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) 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 if OCAML_SUPPORTS_SHARED mypkg_SCRIPTS += stdcompat.cmxs endif endif PACKAGES = 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 stdcompat-21.1/Makefile.in000066400000000000000000002317611505130230400155030ustar00rootroot00000000000000# Makefile.in generated by automake 1.17 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2024 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)) am__rm_f = rm -f $(am__rm_f_notfound) am__rm_rf = rm -rf $(am__rm_f_notfound) 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_NATIVE_TRUE@@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_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_tests.ml \ 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__dynarray_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__dynarray_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__dynarray.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__dynarray.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 ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && echo $$files | $(am__xargs_n) 40 $(am__rm_f); }; \ } 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) am__DIST_COMMON = $(srcdir)/META.in $(srcdir)/Makefile.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__dynarray.ml.in \ $(srcdir)/stdcompat__dynarray.mli.in \ $(srcdir)/stdcompat__dynarray_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__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.md 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 -700 -exec chmod u+rwx {} ';' \ ; rm -rf "$(distdir)" \ || { sleep 5 && rm -rf "$(distdir)"; }; \ else :; fi am__post_remove_distdir = $(am__remove_distdir) DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = -9 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 -a \! \ \( -name .nfs* -o -name .smb* -o -name .__afs* \) \) -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_BEFORE_5_3_0 = @BEGIN_BEFORE_5_3_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_FROM_5_3_0 = @BEGIN_FROM_5_3_0@ BEGIN_WITHOUT_CYGWIN = @BEGIN_WITHOUT_CYGWIN@ BEGIN_WITHOUT_FLAMBDA2 = @BEGIN_WITHOUT_FLAMBDA2@ BEGIN_WITHOUT_MAGIC = @BEGIN_WITHOUT_MAGIC@ 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_UNIX = @BEGIN_WITH_UNIX@ BEGIN_WITH_WIN32 = @BEGIN_WITH_WIN32@ CMAX = @CMAX@ 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_BEFORE_5_3_0 = @C_BEGIN_BEFORE_5_3_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_FROM_5_3_0 = @C_BEGIN_FROM_5_3_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_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_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_BEFORE_5_3_0 = @C_END_BEFORE_5_3_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_FROM_5_3_0 = @C_END_FROM_5_3_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_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_UNIX = @C_END_WITH_UNIX@ C_END_WITH_WIN32 = @C_END_WITH_WIN32@ DEFS = @DEFS@ 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_BEFORE_5_3_0 = @END_BEFORE_5_3_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_FROM_5_3_0 = @END_FROM_5_3_0@ END_WITHOUT_CYGWIN = @END_WITHOUT_CYGWIN@ END_WITHOUT_FLAMBDA2 = @END_WITHOUT_FLAMBDA2@ END_WITHOUT_MAGIC = @END_WITHOUT_MAGIC@ 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_UNIX = @END_WITH_UNIX@ END_WITH_WIN32 = @END_WITH_WIN32@ ETAGS = @ETAGS@ INCLUDE_DEPEND = @INCLUDE_DEPEND@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ 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@ SET_MAKE = @SET_MAKE@ SHARED_LIBS = @SHARED_LIBS@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ am__leading_dot = @am__leading_dot@ am__rm_f_notfound = @am__rm_f_notfound@ am__tar = @am__tar@ am__untar = @am__untar@ am__xargs_n = @am__xargs_n@ 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 autogen VERSION \ stdcompat__dynarray.mli 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__dynarray_s.ml stdcompat__dynarray.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/ocamllibs/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) $(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 = 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: 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): 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_tests.ml: $(top_builddir)/config.status $(srcdir)/stdcompat_tests.ml.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__dynarray_s.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__dynarray_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__dynarray_s.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__dynarray_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__dynarray.ml: $(top_builddir)/config.status $(srcdir)/stdcompat__dynarray.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__dynarray.mli: $(top_builddir)/config.status $(srcdir)/stdcompat__dynarray.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) tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(DISTFILES) $(am__remove_distdir) $(AM_V_at)$(MKDIR_P) "$(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 -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 -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) 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: -$(am__rm_f) $(CLEANFILES) distclean-generic: -$(am__rm_f) $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || $(am__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 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: install-am install-exec-am install-strip .PHONY: all all-am am--refresh check check-am clean clean-generic \ cscopelist-am 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 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-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: # Tell GNU make to disable its built-in pattern rules. %:: %,v %:: RCS/%,v %:: RCS/% %:: s.% %:: SCCS/s.% stdcompat-21.1/NEWS000066400000000000000000000000151505130230400141170ustar00rootroot00000000000000See ChangeLogstdcompat-21.1/README.md000066400000000000000000000107711505130230400147110ustar00rootroot00000000000000``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 --------------------- First, configure stdcompat by running its `./configure` script. Among the options you may want to pass to `./configure`, there is `--disable-magic` to build without using `Obj.magic` (that is, to use the pure but less efficient implementation). Then run `make` and `make install`. Alternatively, the package can also be built with the `dune build --ignore-promoted-rules` command. 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`. stdcompat-21.1/VERSION000066400000000000000000000000041505130230400144660ustar00rootroot0000000000000021.0stdcompat-21.1/_generated-files000066400000000000000000000107611505130230400165510ustar00rootroot00000000000000stdcompat__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_tests.ml 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__dynarray_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__dynarray_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__dynarray.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__dynarray.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 stdcompat-21.1/aclocal.m4000066400000000000000000001074321505130230400152730ustar00rootroot00000000000000# generated automatically by aclocal 1.17 -*- Autoconf -*- # Copyright (C) 1996-2024 Free Software Foundation, Inc. # This file 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. m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.72],, [m4_warning([this file was generated for autoconf 2.72. You have another version of autoconf. It may work, but is not guaranteed to. If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically 'autoreconf'.])]) # Copyright (C) 2002-2024 Free Software Foundation, Inc. # # This file 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. # AM_AUTOMAKE_VERSION(VERSION) # ---------------------------- # Automake X.Y traces this macro to ensure aclocal.m4 has been # generated from the m4 files accompanying Automake X.Y. # (This private macro should not be called outside this file.) AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version='1.17' dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to dnl require some minimum version. Point them to the right macro. m4_if([$1], [1.17], [], [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl ]) # _AM_AUTOCONF_VERSION(VERSION) # ----------------------------- # aclocal traces this macro to find the Autoconf version. # This is a private macro too. Using m4_define simplifies # the logic in aclocal, which can simply ignore this definition. m4_define([_AM_AUTOCONF_VERSION], []) # AM_SET_CURRENT_AUTOMAKE_VERSION # ------------------------------- # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. # This function is AC_REQUIREd by AM_INIT_AUTOMAKE. AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], [AM_AUTOMAKE_VERSION([1.17])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- # Copyright (C) 2001-2024 Free Software Foundation, Inc. # # This file 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. # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets # $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to # '$srcdir', '$srcdir/..', or '$srcdir/../..'. # # Of course, Automake must honor this variable whenever it calls a # tool from the auxiliary directory. The problem is that $srcdir (and # therefore $ac_aux_dir as well) can be either absolute or relative, # depending on how configure is run. This is pretty annoying, since # it makes $ac_aux_dir quite unusable in subdirectories: in the top # source directory, any form will work fine, but in subdirectories a # relative path needs to be adjusted first. # # $ac_aux_dir/missing # fails when called from a subdirectory if $ac_aux_dir is relative # $top_srcdir/$ac_aux_dir/missing # fails if $ac_aux_dir is absolute, # fails when called from a subdirectory in a VPATH build with # a relative $ac_aux_dir # # The reason of the latter failure is that $top_srcdir and $ac_aux_dir # are both prefixed by $srcdir. In an in-source build this is usually # harmless because $srcdir is '.', but things will broke when you # start a VPATH build or use an absolute $srcdir. # # So we could use something similar to $top_srcdir/$ac_aux_dir/missing, # iff we strip the leading $srcdir from $ac_aux_dir. That would be: # am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` # and then we would define $MISSING as # MISSING="\${SHELL} $am_aux_dir/missing" # This will work as long as MISSING is not called from configure, because # unfortunately $(top_srcdir) has no meaning in configure. # However there are other variables, like CC, which are often used in # configure, and could therefore not use this "fixed" $ac_aux_dir. # # Another solution, used here, is to always expand $ac_aux_dir to an # absolute PATH. The drawback is that using absolute paths prevent a # configured tree to be moved without reconfiguration. AC_DEFUN([AM_AUX_DIR_EXPAND], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997-2024 Free Software Foundation, Inc. # # This file 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. # AM_CONDITIONAL(NAME, SHELL-CONDITION) # ------------------------------------- # Define a conditional. AC_DEFUN([AM_CONDITIONAL], [AC_PREREQ([2.52])dnl m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl AC_SUBST([$1_TRUE])dnl AC_SUBST([$1_FALSE])dnl _AM_SUBST_NOTMAKE([$1_TRUE])dnl _AM_SUBST_NOTMAKE([$1_FALSE])dnl m4_define([_AM_COND_VALUE_$1], [$2])dnl if $2; then $1_TRUE= $1_FALSE='#' else $1_TRUE='#' $1_FALSE= fi AC_CONFIG_COMMANDS_PRE( [if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then AC_MSG_ERROR([[conditional "$1" was never defined. Usually this means the macro was only invoked conditionally.]]) fi])]) # Do all the work for Automake. -*- Autoconf -*- # Copyright (C) 1996-2024 Free Software Foundation, Inc. # # This file 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 macro actually does too much. Some checks are only needed if # your package does certain things. But this isn't really a big deal. dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O. m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC]) [_AM_PROG_CC_C_O ]) # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) # AM_INIT_AUTOMAKE([OPTIONS]) # ----------------------------------------------- # The call with PACKAGE and VERSION arguments is the old style # call (pre autoconf-2.50), which is being phased out. PACKAGE # and VERSION should now be passed to AC_INIT and removed from # the call to AM_INIT_AUTOMAKE. # We support both call styles for the transition. After # the next Automake release, Autoconf can make the AC_INIT # arguments mandatory, and then we can depend on a new Autoconf # release and drop the old call support. AC_DEFUN([AM_INIT_AUTOMAKE], [AC_PREREQ([2.65])dnl m4_ifdef([_$0_ALREADY_INIT], [m4_fatal([$0 expanded multiple times ]m4_defn([_$0_ALREADY_INIT]))], [m4_define([_$0_ALREADY_INIT], m4_expansion_stack)])dnl dnl Autoconf wants to disallow AM_ names. We explicitly allow dnl the ones we care about. m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl AC_REQUIRE([AC_PROG_INSTALL])dnl if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl # test to see if srcdir already configured if test -f $srcdir/config.status; then AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) 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 AC_SUBST([CYGPATH_W]) # Define the identity of the package. dnl Distinguish between old-style and new-style calls. m4_ifval([$2], [AC_DIAGNOSE([obsolete], [$0: two- and three-arguments forms are deprecated.]) m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl AC_SUBST([PACKAGE], [$1])dnl AC_SUBST([VERSION], [$2])], [_AM_SET_OPTIONS([$1])dnl dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. m4_if( m4_ifset([AC_PACKAGE_NAME], [ok]):m4_ifset([AC_PACKAGE_VERSION], [ok]), [ok:ok],, [m4_fatal([AC_INIT should be called with package and version arguments])])dnl AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl _AM_IF_OPTION([no-define],, [AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl # Some tools Automake needs. AC_REQUIRE([AM_SANITY_CHECK])dnl AC_REQUIRE([AC_ARG_PROGRAM])dnl AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) AM_MISSING_PROG([AUTOCONF], [autoconf]) AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) AM_MISSING_PROG([AUTOHEADER], [autoheader]) AM_MISSING_PROG([MAKEINFO], [makeinfo]) AC_REQUIRE([AM_PROG_INSTALL_SH])dnl AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl AC_REQUIRE([AC_PROG_MKDIR_P])dnl # For better backward compatibility. To be removed once Automake 1.9.x # dies out for good. For more background, see: # # AC_SUBST([mkdir_p], ['$(MKDIR_P)']) # We need awk for the "check" target (and possibly the TAP driver). The # system "awk" is bad on some platforms. AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([AC_PROG_MAKE_SET])dnl AC_REQUIRE([AM_SET_LEADING_DOT])dnl _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], [_AM_PROG_TAR([v7])])]) _AM_IF_OPTION([no-dependencies],, [AC_PROVIDE_IFELSE([AC_PROG_CC], [_AM_DEPENDENCIES([CC])], [m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl AC_PROVIDE_IFELSE([AC_PROG_CXX], [_AM_DEPENDENCIES([CXX])], [m4_define([AC_PROG_CXX], m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl AC_PROVIDE_IFELSE([AC_PROG_OBJC], [_AM_DEPENDENCIES([OBJC])], [m4_define([AC_PROG_OBJC], m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], [_AM_DEPENDENCIES([OBJCXX])], [m4_define([AC_PROG_OBJCXX], m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl ]) # Variables for tags utilities; see am/tags.am if test -z "$CTAGS"; then CTAGS=ctags fi AC_SUBST([CTAGS]) if test -z "$ETAGS"; then ETAGS=etags fi AC_SUBST([ETAGS]) if test -z "$CSCOPE"; then CSCOPE=cscope fi AC_SUBST([CSCOPE]) AC_REQUIRE([_AM_SILENT_RULES])dnl dnl The testsuite driver may need to know about EXEEXT, so add the dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below. AC_CONFIG_COMMANDS_PRE(dnl [m4_provide_if([_AM_COMPILER_EXEEXT], [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl AC_REQUIRE([_AM_PROG_RM_F]) AC_REQUIRE([_AM_PROG_XARGS_N]) dnl The trailing newline in this macro's definition is deliberate, for dnl backward compatibility and to allow trailing 'dnl'-style comments dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841. ]) dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further dnl mangled by Autoconf and run in a shell conditional statement. m4_define([_AC_COMPILER_EXEEXT], m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) # When config.status generates a header, we must update the stamp-h file. # This file resides in the same directory as the config header # that is generated. The stamp files are numbered to have different names. # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the # loop where config.status creates the headers, so we can generate # our stamp files there. AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], [# Compute $1's index in $config_headers. _am_arg=$1 _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"])`/stamp-h[]$_am_stamp_count]) # Copyright (C) 2001-2024 Free Software Foundation, Inc. # # This file 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. # AM_PROG_INSTALL_SH # ------------------ # Define $install_sh. AC_DEFUN([AM_PROG_INSTALL_SH], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl 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 AC_SUBST([install_sh])]) # Copyright (C) 2003-2024 Free Software Foundation, Inc. # # This file 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. # Check whether the underlying file-system supports filenames # with a leading dot. For instance MS-DOS doesn't. AC_DEFUN([AM_SET_LEADING_DOT], [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 AC_SUBST([am__leading_dot])]) # Add --enable-maintainer-mode option to configure. -*- Autoconf -*- # From Jim Meyering # Copyright (C) 1996-2024 Free Software Foundation, Inc. # # This file 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. # AM_MAINTAINER_MODE([DEFAULT-MODE]) # ---------------------------------- # Control maintainer-specific portions of Makefiles. # Default is to disable them, unless 'enable' is passed literally. # For symmetry, 'disable' may be passed as well. Anyway, the user # can override the default with the --enable/--disable switch. AC_DEFUN([AM_MAINTAINER_MODE], [m4_case(m4_default([$1], [disable]), [enable], [m4_define([am_maintainer_other], [disable])], [disable], [m4_define([am_maintainer_other], [enable])], [m4_define([am_maintainer_other], [enable]) m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])]) AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) dnl maintainer-mode's default is 'disable' unless 'enable' is passed AC_ARG_ENABLE([maintainer-mode], [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode], am_maintainer_other[ make rules and dependencies not useful (and sometimes confusing) to the casual installer])], [USE_MAINTAINER_MODE=$enableval], [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes])) AC_MSG_RESULT([$USE_MAINTAINER_MODE]) AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) MAINT=$MAINTAINER_MODE_TRUE AC_SUBST([MAINT])dnl ] ) # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- # Copyright (C) 1997-2024 Free Software Foundation, Inc. # # This file 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. # AM_MISSING_PROG(NAME, PROGRAM) # ------------------------------ AC_DEFUN([AM_MISSING_PROG], [AC_REQUIRE([AM_MISSING_HAS_RUN]) $1=${$1-"${am_missing_run}$2"} AC_SUBST($1)]) # AM_MISSING_HAS_RUN # ------------------ # Define MISSING if not defined so far and test if it is modern enough. # If it is, set am_missing_run to use it, otherwise, to nothing. AC_DEFUN([AM_MISSING_HAS_RUN], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([missing])dnl 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= AC_MSG_WARN(['missing' script is too old or missing]) fi ]) # Helper functions for option handling. -*- Autoconf -*- # Copyright (C) 2001-2024 Free Software Foundation, Inc. # # This file 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. # _AM_MANGLE_OPTION(NAME) # ----------------------- AC_DEFUN([_AM_MANGLE_OPTION], [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) # _AM_SET_OPTION(NAME) # -------------------- # Set option NAME. Presently that only means defining a flag for this option. AC_DEFUN([_AM_SET_OPTION], [m4_define(_AM_MANGLE_OPTION([$1]), [1])]) # _AM_SET_OPTIONS(OPTIONS) # ------------------------ # OPTIONS is a space-separated list of Automake options. AC_DEFUN([_AM_SET_OPTIONS], [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) # _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) # ------------------------------------------- # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. AC_DEFUN([_AM_IF_OPTION], [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) # Copyright (C) 2022-2024 Free Software Foundation, Inc. # # This file 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. # _AM_PROG_RM_F # --------------- # Check whether 'rm -f' without any arguments works. # https://bugs.gnu.org/10828 AC_DEFUN([_AM_PROG_RM_F], [am__rm_f_notfound= AS_IF([(rm -f && rm -fr && rm -rf) 2>/dev/null], [], [am__rm_f_notfound='""']) AC_SUBST(am__rm_f_notfound) ]) # Check to make sure that the build environment is sane. -*- Autoconf -*- # Copyright (C) 1996-2024 Free Software Foundation, Inc. # # This file 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. # _AM_SLEEP_FRACTIONAL_SECONDS # ---------------------------- AC_DEFUN([_AM_SLEEP_FRACTIONAL_SECONDS], [dnl AC_CACHE_CHECK([whether sleep supports fractional seconds], am_cv_sleep_fractional_seconds, [dnl AS_IF([sleep 0.001 2>/dev/null], [am_cv_sleep_fractional_seconds=yes], [am_cv_sleep_fractional_seconds=no]) ])]) # _AM_FILESYSTEM_TIMESTAMP_RESOLUTION # ----------------------------------- # Determine the filesystem's resolution for file modification # timestamps. The coarsest we know of is FAT, with a resolution # of only two seconds, even with the most recent "exFAT" extensions. # The finest (e.g. ext4 with large inodes, XFS, ZFS) is one # nanosecond, matching clock_gettime. However, it is probably not # possible to delay execution of a shell script for less than one # millisecond, due to process creation overhead and scheduling # granularity, so we don't check for anything finer than that. (See below.) AC_DEFUN([_AM_FILESYSTEM_TIMESTAMP_RESOLUTION], [dnl AC_REQUIRE([_AM_SLEEP_FRACTIONAL_SECONDS]) AC_CACHE_CHECK([filesystem timestamp resolution], am_cv_filesystem_timestamp_resolution, [dnl # Default to the worst case. am_cv_filesystem_timestamp_resolution=2 # Only try to go finer than 1 sec if sleep can do it. # Don't try 1 sec, because if 0.01 sec and 0.1 sec don't work, # - 1 sec is not much of a win compared to 2 sec, and # - it takes 2 seconds to perform the test whether 1 sec works. # # Instead, just use the default 2s on platforms that have 1s resolution, # accept the extra 1s delay when using $sleep in the Automake tests, in # exchange for not incurring the 2s delay for running the test for all # packages. # am_try_resolutions= if test "$am_cv_sleep_fractional_seconds" = yes; then # Even a millisecond often causes a bunch of false positives, # so just try a hundredth of a second. The time saved between .001 and # .01 is not terribly consequential. am_try_resolutions="0.01 0.1 $am_try_resolutions" fi # In order to catch current-generation FAT out, we must *modify* files # that already exist; the *creation* timestamp is finer. Use names # that make ls -t sort them differently when they have equal # timestamps than when they have distinct timestamps, keeping # in mind that ls -t prints the *newest* file first. rm -f conftest.ts? : > conftest.ts1 : > conftest.ts2 : > conftest.ts3 # Make sure ls -t actually works. Do 'set' in a subshell so we don't # clobber the current shell's arguments. (Outer-level square brackets # are removed by m4; they're present so that m4 does not expand # ; be careful, easy to get confused.) if ( set X `[ls -t conftest.ts[12]]` && { test "$[]*" != "X conftest.ts1 conftest.ts2" || test "$[]*" != "X conftest.ts2 conftest.ts1"; } ); then :; else # 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_ECHO_UNQUOTED( ["Bad output from ls -t: \"`[ls -t conftest.ts[12]]`\""], [AS_MESSAGE_LOG_FD]) AC_MSG_FAILURE([ls -t produces unexpected output. Make sure there is not a broken ls alias in your environment.]) fi for am_try_res in $am_try_resolutions; do # Any one fine-grained sleep might happen to cross the boundary # between two values of a coarser actual resolution, but if we do # two fine-grained sleeps in a row, at least one of them will fall # entirely within a coarse interval. echo alpha > conftest.ts1 sleep $am_try_res echo beta > conftest.ts2 sleep $am_try_res echo gamma > conftest.ts3 # We assume that 'ls -t' will make use of high-resolution # timestamps if the operating system supports them at all. if (set X `ls -t conftest.ts?` && test "$[]2" = conftest.ts3 && test "$[]3" = conftest.ts2 && test "$[]4" = conftest.ts1); then # # Ok, ls -t worked. If we're at a resolution of 1 second, we're done, # because we don't need to test make. make_ok=true if test $am_try_res != 1; then # But if we've succeeded so far with a subsecond resolution, we # have one more thing to check: make. It can happen that # everything else supports the subsecond mtimes, but make doesn't; # notably on macOS, which ships make 3.81 from 2006 (the last one # released under GPLv2). https://bugs.gnu.org/68808 # # We test $MAKE if it is defined in the environment, else "make". # It might get overridden later, but our hope is that in practice # it does not matter: it is the system "make" which is (by far) # the most likely to be broken, whereas if the user overrides it, # probably they did so with a better, or at least not worse, make. # https://lists.gnu.org/archive/html/automake/2024-06/msg00051.html # # Create a Makefile (real tab character here): rm -f conftest.mk echo 'conftest.ts1: conftest.ts2' >conftest.mk echo ' touch conftest.ts2' >>conftest.mk # # Now, running # touch conftest.ts1; touch conftest.ts2; make # should touch ts1 because ts2 is newer. This could happen by luck, # but most often, it will fail if make's support is insufficient. So # test for several consecutive successes. # # (We reuse conftest.ts[12] because we still want to modify existing # files, not create new ones, per above.) n=0 make=${MAKE-make} until test $n -eq 3; do echo one > conftest.ts1 sleep $am_try_res echo two > conftest.ts2 # ts2 should now be newer than ts1 if $make -f conftest.mk | grep 'up to date' >/dev/null; then make_ok=false break # out of $n loop fi n=`expr $n + 1` done fi # if $make_ok; then # Everything we know to check worked out, so call this resolution good. am_cv_filesystem_timestamp_resolution=$am_try_res break # out of $am_try_res loop fi # Otherwise, we'll go on to check the next resolution. fi done rm -f conftest.ts? # (end _am_filesystem_timestamp_resolution) ])]) # AM_SANITY_CHECK # --------------- AC_DEFUN([AM_SANITY_CHECK], [AC_REQUIRE([_AM_FILESYSTEM_TIMESTAMP_RESOLUTION]) # This check should not be cached, as it may vary across builds of # different projects. AC_MSG_CHECKING([whether build environment is sane]) # 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]]*) AC_MSG_ERROR([unsafe absolute working directory name]);; esac case $srcdir in *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; 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). am_build_env_is_sane=no am_has_slept=no rm -f conftest.file for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file if ( 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 test "$[]2" = conftest.file ); then am_build_env_is_sane=yes break fi # Just in case. sleep "$am_cv_filesystem_timestamp_resolution" am_has_slept=yes done AC_MSG_RESULT([$am_build_env_is_sane]) if test "$am_build_env_is_sane" = no; then AC_MSG_ERROR([newly created file is older than distributed files! Check your system clock]) fi # If we didn't sleep, we still need to ensure time stamps of config.status and # generated files are strictly newer. am_sleep_pid= AS_IF([test -e conftest.file || grep 'slept: no' conftest.file >/dev/null 2>&1],, [dnl ( sleep "$am_cv_filesystem_timestamp_resolution" ) & am_sleep_pid=$! ]) AC_CONFIG_COMMANDS_PRE( [AC_MSG_CHECKING([that generated files are newer than configure]) if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi AC_MSG_RESULT([done])]) rm -f conftest.file ]) # Copyright (C) 2009-2024 Free Software Foundation, Inc. # # This file 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. # _AM_SILENT_RULES # ---------------- # Enable less verbose build rules support. AC_DEFUN([_AM_SILENT_RULES], [AM_DEFAULT_VERBOSITY=1 AC_ARG_ENABLE([silent-rules], [dnl AS_HELP_STRING( [--enable-silent-rules], [less verbose build output (undo: "make V=1")]) AS_HELP_STRING( [--disable-silent-rules], [verbose build output (undo: "make V=0")])dnl ]) dnl dnl A few 'make' implementations (e.g., NonStop OS and NextStep) dnl do not support nested variable expansions. dnl See automake bug#9928 and bug#10237. am_make=${MAKE-make} AC_CACHE_CHECK([whether $am_make supports nested variables], [am_cv_make_support_nested_variables], [if AS_ECHO([['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]) AC_SUBST([AM_V])dnl AM_SUBST_NOTMAKE([AM_V])dnl AC_SUBST([AM_DEFAULT_V])dnl AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl AC_SUBST([AM_DEFAULT_VERBOSITY])dnl AM_BACKSLASH='\' AC_SUBST([AM_BACKSLASH])dnl _AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl dnl Delay evaluation of AM_DEFAULT_VERBOSITY to the end to allow multiple calls dnl to AM_SILENT_RULES to change the default value. AC_CONFIG_COMMANDS_PRE([dnl case $enable_silent_rules in @%:@ ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; esac if test $am_cv_make_support_nested_variables = yes; then dnl Using '$V' instead of '$(V)' breaks IRIX make. AM_V='$(V)' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi ])dnl ]) # AM_SILENT_RULES([DEFAULT]) # -------------------------- # Set the default verbosity level to DEFAULT ("yes" being less verbose, "no" or # empty being verbose). AC_DEFUN([AM_SILENT_RULES], [AC_REQUIRE([_AM_SILENT_RULES]) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1])]) # Copyright (C) 2001-2024 Free Software Foundation, Inc. # # This file 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. # AM_PROG_INSTALL_STRIP # --------------------- # One issue with vendor 'install' (even GNU) is that you can't # specify the program used to strip binaries. This is especially # annoying in cross-compiling environments, where the build's strip # is unlikely to handle the host's binaries. # Fortunately install-sh will honor a STRIPPROG variable, so we # always use install-sh in "make install-strip", and initialize # STRIPPROG with the value of the STRIP variable (set by the user). AC_DEFUN([AM_PROG_INSTALL_STRIP], [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl # 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. dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. if test "$cross_compiling" != no; then AC_CHECK_TOOL([STRIP], [strip], :) fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" AC_SUBST([INSTALL_STRIP_PROGRAM])]) # Copyright (C) 2006-2024 Free Software Foundation, Inc. # # This file 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. # _AM_SUBST_NOTMAKE(VARIABLE) # --------------------------- # Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. # This macro is traced by Automake. AC_DEFUN([_AM_SUBST_NOTMAKE]) # AM_SUBST_NOTMAKE(VARIABLE) # -------------------------- # Public sister of _AM_SUBST_NOTMAKE. AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) # Check how to create a tarball. -*- Autoconf -*- # Copyright (C) 2004-2024 Free Software Foundation, Inc. # # This file 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. # _AM_PROG_TAR(FORMAT) # -------------------- # Check how to create a tarball in format FORMAT. # FORMAT should be one of 'v7', 'ustar', or 'pax'. # # Substitute a variable $(am__tar) that is a command # writing to stdout a FORMAT-tarball containing the directory # $tardir. # tardir=directory && $(am__tar) > result.tar # # Substitute a variable $(am__untar) that extract such # a tarball read from stdin. # $(am__untar) < result.tar # AC_DEFUN([_AM_PROG_TAR], [# Always define AMTAR for backward compatibility. Yes, it's still used # in the wild :-( We should find a proper way to deprecate it ... AC_SUBST([AMTAR], ['$${TAR-tar}']) # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' m4_if([$1], [v7], [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], [m4_case([$1], [ustar], [# The POSIX 1988 'ustar' format is defined with fixed-size fields. # There is notably a 21 bits limit for the UID and the GID. In fact, # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343 # and bug#13588). am_max_uid=2097151 # 2^21 - 1 am_max_gid=$am_max_uid # The $UID and $GID variables are not portable, so we need to resort # to the POSIX-mandated id(1) utility. Errors in the 'id' calls # below are definitely unexpected, so allow the users to see them # (that is, avoid stderr redirection). am_uid=`id -u || echo unknown` am_gid=`id -g || echo unknown` AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format]) if test x$am_uid = xunknown; then AC_MSG_WARN([ancient id detected; assuming current UID is ok, but dist-ustar might not work]) elif test $am_uid -le $am_max_uid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format]) if test x$gm_gid = xunknown; then AC_MSG_WARN([ancient id detected; assuming current GID is ok, but dist-ustar might not work]) elif test $am_gid -le $am_max_gid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi], [pax], [], [m4_fatal([Unknown tar format])]) AC_MSG_CHECKING([how to create a $1 tar archive]) # Go ahead even if we have the value already cached. We do so because we # need to set the values for the 'am__tar' and 'am__untar' variables. _am_tools=${am_cv_prog_tar_$1-$_am_tools} for _am_tool in $_am_tools; do case $_am_tool in gnutar) for _am_tar in tar gnutar gtar; do AM_RUN_LOG([$_am_tar --version]) && break done am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' am__untar="$_am_tar -xf -" ;; plaintar) # Must skip GNU tar: if it does not support --format= it doesn't create # ustar tarball either. (tar --version) >/dev/null 2>&1 && continue am__tar='tar chf - "$$tardir"' am__tar_='tar chf - "$tardir"' am__untar='tar xf -' ;; pax) am__tar='pax -L -x $1 -w "$$tardir"' am__tar_='pax -L -x $1 -w "$tardir"' am__untar='pax -r' ;; cpio) am__tar='find "$$tardir" -print | cpio -o -H $1 -L' am__tar_='find "$tardir" -print | cpio -o -H $1 -L' am__untar='cpio -i -H $1 -d' ;; none) am__tar=false am__tar_=false am__untar=false ;; esac # If the value was cached, stop now. We just wanted to have am__tar # and am__untar set. test -n "${am_cv_prog_tar_$1}" && break # tar/untar a dummy directory, and stop if the command works. rm -rf conftest.dir mkdir conftest.dir echo GrepMe > conftest.dir/file AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) rm -rf conftest.dir if test -s conftest.tar; then AM_RUN_LOG([$am__untar /dev/null 2>&1 && break fi done rm -rf conftest.dir AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) AC_MSG_RESULT([$am_cv_prog_tar_$1])]) AC_SUBST([am__tar]) AC_SUBST([am__untar]) ]) # _AM_PROG_TAR # Copyright (C) 2022-2024 Free Software Foundation, Inc. # # This file 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. # _AM_PROG_XARGS_N # ---------------- # Check whether 'xargs -n' works. It should work everywhere, so the fallback # is not optimized at all as we never expect to use it. AC_DEFUN([_AM_PROG_XARGS_N], [AC_CACHE_CHECK([xargs -n works], am_cv_xargs_n_works, [dnl AS_IF([test "`echo 1 2 3 | xargs -n2 echo`" = "1 2 3"], [am_cv_xargs_n_works=yes], [am_cv_xargs_n_works=no])]) AS_IF([test "$am_cv_xargs_n_works" = yes], [am__xargs_n='xargs -n'], [dnl am__xargs_n='am__xargs_n () { shift; sed "s/ /\\n/g" | while read am__xargs_n_arg; do "$@" "$am__xargs_n_arg"; done; }' ])dnl AC_SUBST(am__xargs_n) ]) stdcompat-21.1/autogen000077500000000000000000000001161505130230400150120ustar00rootroot00000000000000#!/bin/sh aclocal automake --add-missing autoconf ./tools/generate-dune-rules stdcompat-21.1/compile000077500000000000000000000163501505130230400150070ustar00rootroot00000000000000#! /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: stdcompat-21.1/configure000077500000000000000000006223071505130230400153450ustar00rootroot00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.72 for stdcompat 21.0. # # 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: [https://github.com/ocamllibs/stdcompat/issues] about $0: your system, including any error possibly output before $0: this message. Then install a modern shell, or manually $0: run 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='21.0' PACKAGE_STRING='stdcompat 21.0' PACKAGE_BUGREPORT='https://github.com/ocamllibs/stdcompat/issues' PACKAGE_URL='https://github.com/ocamllibs/stdcompat/' ac_subst_vars='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_3_0 C_BEGIN_BEFORE_5_3_0 END_BEFORE_5_3_0 BEGIN_BEFORE_5_3_0 C_END_FROM_5_3_0 C_BEGIN_FROM_5_3_0 END_FROM_5_3_0 BEGIN_FROM_5_3_0 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_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 OBJEXT CMAX OCAMLBEST 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__xargs_n am__rm_f_notfound 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' ac_subst_files='' ac_user_opts=' enable_option_checking enable_silent_rules enable_maintainer_mode enable_magic ' ac_precious_vars='build_alias host_alias target_alias' # 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 21.0 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 21.0:";; 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-magic [use Obj.magic in redefinitions when possible (default)], --disable-magic [use only pure redefinitions (without Obj.magic)] 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 21.0 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_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 21.0, 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 # Auxiliary files required by this configure script. ac_aux_files="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.17' # 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 sleep supports fractional seconds" >&5 printf %s "checking whether sleep supports fractional seconds... " >&6; } if test ${am_cv_sleep_fractional_seconds+y} then : printf %s "(cached) " >&6 else case e in #( e) if sleep 0.001 2>/dev/null then : am_cv_sleep_fractional_seconds=yes else case e in #( e) am_cv_sleep_fractional_seconds=no ;; esac fi ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_sleep_fractional_seconds" >&5 printf "%s\n" "$am_cv_sleep_fractional_seconds" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking filesystem timestamp resolution" >&5 printf %s "checking filesystem timestamp resolution... " >&6; } if test ${am_cv_filesystem_timestamp_resolution+y} then : printf %s "(cached) " >&6 else case e in #( e) # Default to the worst case. am_cv_filesystem_timestamp_resolution=2 # Only try to go finer than 1 sec if sleep can do it. # Don't try 1 sec, because if 0.01 sec and 0.1 sec don't work, # - 1 sec is not much of a win compared to 2 sec, and # - it takes 2 seconds to perform the test whether 1 sec works. # # Instead, just use the default 2s on platforms that have 1s resolution, # accept the extra 1s delay when using $sleep in the Automake tests, in # exchange for not incurring the 2s delay for running the test for all # packages. # am_try_resolutions= if test "$am_cv_sleep_fractional_seconds" = yes; then # Even a millisecond often causes a bunch of false positives, # so just try a hundredth of a second. The time saved between .001 and # .01 is not terribly consequential. am_try_resolutions="0.01 0.1 $am_try_resolutions" fi # In order to catch current-generation FAT out, we must *modify* files # that already exist; the *creation* timestamp is finer. Use names # that make ls -t sort them differently when they have equal # timestamps than when they have distinct timestamps, keeping # in mind that ls -t prints the *newest* file first. rm -f conftest.ts? : > conftest.ts1 : > conftest.ts2 : > conftest.ts3 # Make sure ls -t actually works. Do 'set' in a subshell so we don't # clobber the current shell's arguments. (Outer-level square brackets # are removed by m4; they're present so that m4 does not expand # ; be careful, easy to get confused.) if ( set X `ls -t conftest.ts[12]` && { test "$*" != "X conftest.ts1 conftest.ts2" || test "$*" != "X conftest.ts2 conftest.ts1"; } ); then :; else # 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". printf "%s\n" ""Bad output from ls -t: \"`ls -t conftest.ts[12]`\""" >&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 $? "ls -t produces unexpected output. Make sure there is not a broken ls alias in your environment. See 'config.log' for more details" "$LINENO" 5; } fi for am_try_res in $am_try_resolutions; do # Any one fine-grained sleep might happen to cross the boundary # between two values of a coarser actual resolution, but if we do # two fine-grained sleeps in a row, at least one of them will fall # entirely within a coarse interval. echo alpha > conftest.ts1 sleep $am_try_res echo beta > conftest.ts2 sleep $am_try_res echo gamma > conftest.ts3 # We assume that 'ls -t' will make use of high-resolution # timestamps if the operating system supports them at all. if (set X `ls -t conftest.ts?` && test "$2" = conftest.ts3 && test "$3" = conftest.ts2 && test "$4" = conftest.ts1); then # # Ok, ls -t worked. If we're at a resolution of 1 second, we're done, # because we don't need to test make. make_ok=true if test $am_try_res != 1; then # But if we've succeeded so far with a subsecond resolution, we # have one more thing to check: make. It can happen that # everything else supports the subsecond mtimes, but make doesn't; # notably on macOS, which ships make 3.81 from 2006 (the last one # released under GPLv2). https://bugs.gnu.org/68808 # # We test $MAKE if it is defined in the environment, else "make". # It might get overridden later, but our hope is that in practice # it does not matter: it is the system "make" which is (by far) # the most likely to be broken, whereas if the user overrides it, # probably they did so with a better, or at least not worse, make. # https://lists.gnu.org/archive/html/automake/2024-06/msg00051.html # # Create a Makefile (real tab character here): rm -f conftest.mk echo 'conftest.ts1: conftest.ts2' >conftest.mk echo ' touch conftest.ts2' >>conftest.mk # # Now, running # touch conftest.ts1; touch conftest.ts2; make # should touch ts1 because ts2 is newer. This could happen by luck, # but most often, it will fail if make's support is insufficient. So # test for several consecutive successes. # # (We reuse conftest.ts[12] because we still want to modify existing # files, not create new ones, per above.) n=0 make=${MAKE-make} until test $n -eq 3; do echo one > conftest.ts1 sleep $am_try_res echo two > conftest.ts2 # ts2 should now be newer than ts1 if $make -f conftest.mk | grep 'up to date' >/dev/null; then make_ok=false break # out of $n loop fi n=`expr $n + 1` done fi # if $make_ok; then # Everything we know to check worked out, so call this resolution good. am_cv_filesystem_timestamp_resolution=$am_try_res break # out of $am_try_res loop fi # Otherwise, we'll go on to check the next resolution. fi done rm -f conftest.ts? # (end _am_filesystem_timestamp_resolution) ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_filesystem_timestamp_resolution" >&5 printf "%s\n" "$am_cv_filesystem_timestamp_resolution" >&6; } # This check should not be cached, as it may vary across builds of # different projects. { 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). am_build_env_is_sane=no am_has_slept=no rm -f conftest.file for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file if ( 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 test "$2" = conftest.file ); then am_build_env_is_sane=yes break fi # Just in case. sleep "$am_cv_filesystem_timestamp_resolution" am_has_slept=yes done { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_build_env_is_sane" >&5 printf "%s\n" "$am_build_env_is_sane" >&6; } if test "$am_build_env_is_sane" = no; then as_fn_error $? "newly created file is older than distributed files! Check your system clock" "$LINENO" 5 fi # 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 test -e conftest.file || grep 'slept: no' conftest.file >/dev/null 2>&1 then : else case e in #( e) ( sleep "$am_cv_filesystem_timestamp_resolution" ) & am_sleep_pid=$! ;; esac 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 AM_DEFAULT_VERBOSITY=1 # Check whether --enable-silent-rules was given. if test ${enable_silent_rules+y} then : enableval=$enable_silent_rules; fi 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; } AM_BACKSLASH='\' am__rm_f_notfound= if (rm -f && rm -fr && rm -rf) 2>/dev/null then : else case e in #( e) am__rm_f_notfound='""' ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking xargs -n works" >&5 printf %s "checking xargs -n works... " >&6; } if test ${am_cv_xargs_n_works+y} then : printf %s "(cached) " >&6 else case e in #( e) if test "`echo 1 2 3 | xargs -n2 echo`" = "1 2 3" then : am_cv_xargs_n_works=yes else case e in #( e) am_cv_xargs_n_works=no ;; esac fi ;; esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_xargs_n_works" >&5 printf "%s\n" "$am_cv_xargs_n_works" >&6; } if test "$am_cv_xargs_n_works" = yes then : am__xargs_n='xargs -n' else case e in #( e) am__xargs_n='am__xargs_n () { shift; sed "s/ /\\n/g" | while read am__xargs_n_arg; do "" "$am__xargs_n_arg"; done; }' ;; esac fi 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='21.0' 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 { 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" ;; 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 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: the best OCaml compiler is $OCAMLBEST" >&5 printf "%s\n" "$as_me: the best OCaml compiler is $OCAMLBEST" >&6;} if test "x$OCAMLDEP" = "x" then : as_fn_error $? "No ocamldep available" "$LINENO" 5 fi OBJEXT=`$OCAMLBEST -config-var ext_obj | sed 's/^[.]//g'` { 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 `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 `printf "$OCAMLVERSION\n5.3.0" | sort | head -n1` = 5.3.0 then : BEGIN_BEFORE_5_3_0='(*' END_BEFORE_5_3_0='*)' C_BEGIN_BEFORE_5_3_0='#if 0' C_END_BEFORE_5_3_0='#endif' else case e in #( e) BEGIN_FROM_5_3_0='(*' END_FROM_5_3_0='*)' C_BEGIN_FROM_5_3_0='#if 0' C_END_FROM_5_3_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_tests.ml" 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__dynarray_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__dynarray_s.ml:stdcompat__dynarray_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__dynarray.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__dynarray.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}' # Transform confdefs.h into DEFS. # Protect against shell expansion while executing Makefile rules. # Protect against Makefile macro expansion. # # If the first sed substitution is executed (which looks for macros that # take arguments), then branch to the quote section. Otherwise, # look for a macro that doesn't take arguments. ac_script=' :mline /\\$/{ N s,\\\n,, b mline } t clear :clear s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g t quote s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g t quote b any :quote s/[][ `~#$^&*(){}\\|;'\''"<>?]/\\&/g s/\$/$$/g H :any ${ g s/^\n// s/\n/ /g p } ' DEFS=`sed -n "$ac_script" confdefs.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; } case $enable_silent_rules in # ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; esac 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 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 "${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 21.0, 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 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" _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 Configuration files: $config_files 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 21.0 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;; --he | --h | --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 _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 "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_tests.ml") CONFIG_FILES="$CONFIG_FILES stdcompat_tests.ml" ;; "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__dynarray_s.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__dynarray_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__dynarray_s.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__dynarray_s.ml:stdcompat__dynarray_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__dynarray.ml") CONFIG_FILES="$CONFIG_FILES stdcompat__dynarray.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__dynarray.mli") CONFIG_FILES="$CONFIG_FILES stdcompat__dynarray.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 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" eval set X " :F $CONFIG_FILES " 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 ;; 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 stdcompat-21.1/configure.ac000066400000000000000000000443571505130230400157270ustar00rootroot00000000000000AC_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([OCAMLC], [["$OCAMLFIND ocamlc"]]) AC_SUBST([OCAMLOPT], [["$OCAMLFIND ocamlopt"]]) AC_SUBST([OCAMLDOC], [["$OCAMLFIND ocamldoc"]]) AC_SUBST([OCAMLDEP], [["$OCAMLFIND ocamldep"]]) AC_SUBST([OCAMLMKLIB], [["$OCAMLFIND ocamlmklib"]])]) 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"]])]) AC_MSG_NOTICE([the best OCaml compiler is $OCAMLBEST]) AS_IF([test "x$OCAMLDEP" = "x"], [AC_MSG_ERROR([[No ocamldep available]])]) AC_SUBST([OBJEXT], [[`$OCAMLBEST -config-var ext_obj | sed 's/^[.]//g'`]]) 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_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]) AC_WITH_OCAML_VERSION([5_3_0], [5.3.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_tests.ml]) 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__dynarray_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__dynarray_s.ml:stdcompat__dynarray_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__dynarray.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__dynarray.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).]])]) stdcompat-21.1/dockerfiles/000077500000000000000000000000001505130230400157165ustar00rootroot00000000000000stdcompat-21.1/dockerfiles/ocaml-5-beta/000077500000000000000000000000001505130230400200645ustar00rootroot00000000000000stdcompat-21.1/dockerfiles/ocaml-5-beta/Dockerfile000066400000000000000000000012521505130230400220560ustar00rootroot00000000000000FROM 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 ARG switches=5.0.0~alpha1 RUN opam update && for switch in ${switches}; do opam switch create $switch; done USER rootstdcompat-21.1/dockerfiles/old-ocamls/000077500000000000000000000000001505130230400177505ustar00rootroot00000000000000stdcompat-21.1/dockerfiles/old-ocamls/Dockerfile000066400000000000000000000016441505130230400217470ustar00rootroot00000000000000FROM 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 USER rootstdcompat-21.1/dune000066400000000000000000000051511505130230400143040ustar00rootroot00000000000000(library (name stdcompat) (public_name stdcompat) (wrapped false) (flags (:standard -nolabels -w -3)) (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__dynarray stdcompat__dynarray_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)) (include dune-rules.inc) stdcompat-21.1/dune-project000066400000000000000000000000411505130230400157410ustar00rootroot00000000000000(lang dune 2.0) (name stdcompat) stdcompat-21.1/dune-rules.inc000066400000000000000000001504621505130230400162120ustar00rootroot00000000000000(rule (targets stdcompat__hashtbl_ext.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__hashtbl_ext.mli.in) (action (with-stdin-from stdcompat__hashtbl_ext.mli.in (with-stdout-to stdcompat__hashtbl_ext.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__hashtbl_ext.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__hashtbl_ext.ml.in) (action (with-stdin-from stdcompat__hashtbl_ext.ml.in (with-stdout-to stdcompat__hashtbl_ext.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__init.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__init.mli.in) (action (with-stdin-from stdcompat__init.mli.in (with-stdout-to stdcompat__init.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__init.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__init.mli.in) (action (with-stdin-from stdcompat__init.mli.in (with-stdout-to stdcompat__init.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__root.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__root.mli.in) (action (with-stdin-from stdcompat__root.mli.in (with-stdout-to stdcompat__root.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__root.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__root.ml.in) (action (with-stdin-from stdcompat__root.ml.in (with-stdout-to stdcompat__root.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__tools.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__tools.mli.in) (action (with-stdin-from stdcompat__tools.mli.in (with-stdout-to stdcompat__tools.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__tools.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__tools.ml.in) (action (with-stdin-from stdcompat__tools.ml.in (with-stdout-to stdcompat__tools.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat_tests.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat_tests.ml.in) (action (with-stdin-from stdcompat_tests.ml.in (with-stdout-to stdcompat_tests.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stubs.c) (deps (:gen tools/stdcompatpp.exe) stdcompat__stubs.c.in) (action (with-stdin-from stdcompat__stubs.c.in (with-stdout-to stdcompat__stubs.c (run %{gen} --source-type c))))) (rule (targets stdcompat__pervasives_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__pervasives_s.mli.in) (action (with-stdin-from stdcompat__pervasives_s.mli.in (with-stdout-to stdcompat__pervasives_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arg_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__arg_s.mli.in) (action (with-stdin-from stdcompat__arg_s.mli.in (with-stdout-to stdcompat__arg_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__array_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__array_s.mli.in) (action (with-stdin-from stdcompat__array_s.mli.in (with-stdout-to stdcompat__array_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arrayLabels_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__arrayLabels_s.mli.in) (action (with-stdin-from stdcompat__arrayLabels_s.mli.in (with-stdout-to stdcompat__arrayLabels_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__atomic_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__atomic_s.mli.in) (action (with-stdin-from stdcompat__atomic_s.mli.in (with-stdout-to stdcompat__atomic_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bool_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__bool_s.mli.in) (action (with-stdin-from stdcompat__bool_s.mli.in (with-stdout-to stdcompat__bool_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__buffer_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__buffer_s.mli.in) (action (with-stdin-from stdcompat__buffer_s.mli.in (with-stdout-to stdcompat__buffer_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytes_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytes_s.mli.in) (action (with-stdin-from stdcompat__bytes_s.mli.in (with-stdout-to stdcompat__bytes_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytesLabels_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytesLabels_s.mli.in) (action (with-stdin-from stdcompat__bytesLabels_s.mli.in (with-stdout-to stdcompat__bytesLabels_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__char_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__char_s.mli.in) (action (with-stdin-from stdcompat__char_s.mli.in (with-stdout-to stdcompat__char_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__digest_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__digest_s.mli.in) (action (with-stdin-from stdcompat__digest_s.mli.in (with-stdout-to stdcompat__digest_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__domain_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__domain_s.mli.in) (action (with-stdin-from stdcompat__domain_s.mli.in (with-stdout-to stdcompat__domain_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__dynarray_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__dynarray_s.mli.in) (action (with-stdin-from stdcompat__dynarray_s.mli.in (with-stdout-to stdcompat__dynarray_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__either_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__either_s.mli.in) (action (with-stdin-from stdcompat__either_s.mli.in (with-stdout-to stdcompat__either_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__ephemeron_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__ephemeron_s.mli.in) (action (with-stdin-from stdcompat__ephemeron_s.mli.in (with-stdout-to stdcompat__ephemeron_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__filename_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__filename_s.mli.in) (action (with-stdin-from stdcompat__filename_s.mli.in (with-stdout-to stdcompat__filename_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__float_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__float_s.mli.in) (action (with-stdin-from stdcompat__float_s.mli.in (with-stdout-to stdcompat__float_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__format_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__format_s.mli.in) (action (with-stdin-from stdcompat__format_s.mli.in (with-stdout-to stdcompat__format_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__fun_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__fun_s.mli.in) (action (with-stdin-from stdcompat__fun_s.mli.in (with-stdout-to stdcompat__fun_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__hashtbl_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__hashtbl_s.mli.in) (action (with-stdin-from stdcompat__hashtbl_s.mli.in (with-stdout-to stdcompat__hashtbl_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__in_channel_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__in_channel_s.mli.in) (action (with-stdin-from stdcompat__in_channel_s.mli.in (with-stdout-to stdcompat__in_channel_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__int_s.mli.in) (action (with-stdin-from stdcompat__int_s.mli.in (with-stdout-to stdcompat__int_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int32_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__int32_s.mli.in) (action (with-stdin-from stdcompat__int32_s.mli.in (with-stdout-to stdcompat__int32_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int64_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__int64_s.mli.in) (action (with-stdin-from stdcompat__int64_s.mli.in (with-stdout-to stdcompat__int64_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lazy_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__lazy_s.mli.in) (action (with-stdin-from stdcompat__lazy_s.mli.in (with-stdout-to stdcompat__lazy_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lexing_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__lexing_s.mli.in) (action (with-stdin-from stdcompat__lexing_s.mli.in (with-stdout-to stdcompat__lexing_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__list_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__list_s.mli.in) (action (with-stdin-from stdcompat__list_s.mli.in (with-stdout-to stdcompat__list_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__listLabels_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__listLabels_s.mli.in) (action (with-stdin-from stdcompat__listLabels_s.mli.in (with-stdout-to stdcompat__listLabels_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__map_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__map_s.mli.in) (action (with-stdin-from stdcompat__map_s.mli.in (with-stdout-to stdcompat__map_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__moreLabels_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__moreLabels_s.mli.in) (action (with-stdin-from stdcompat__moreLabels_s.mli.in (with-stdout-to stdcompat__moreLabels_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__nativeint_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__nativeint_s.mli.in) (action (with-stdin-from stdcompat__nativeint_s.mli.in (with-stdout-to stdcompat__nativeint_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__option_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__option_s.mli.in) (action (with-stdin-from stdcompat__option_s.mli.in (with-stdout-to stdcompat__option_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__out_channel_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__out_channel_s.mli.in) (action (with-stdin-from stdcompat__out_channel_s.mli.in (with-stdout-to stdcompat__out_channel_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printexc_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__printexc_s.mli.in) (action (with-stdin-from stdcompat__printexc_s.mli.in (with-stdout-to stdcompat__printexc_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printf_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__printf_s.mli.in) (action (with-stdin-from stdcompat__printf_s.mli.in (with-stdout-to stdcompat__printf_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__queue_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__queue_s.mli.in) (action (with-stdin-from stdcompat__queue_s.mli.in (with-stdout-to stdcompat__queue_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__random_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__random_s.mli.in) (action (with-stdin-from stdcompat__random_s.mli.in (with-stdout-to stdcompat__random_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__result_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__result_s.mli.in) (action (with-stdin-from stdcompat__result_s.mli.in (with-stdout-to stdcompat__result_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__seq_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__seq_s.mli.in) (action (with-stdin-from stdcompat__seq_s.mli.in (with-stdout-to stdcompat__seq_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__set_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__set_s.mli.in) (action (with-stdin-from stdcompat__set_s.mli.in (with-stdout-to stdcompat__set_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stack_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__stack_s.mli.in) (action (with-stdin-from stdcompat__stack_s.mli.in (with-stdout-to stdcompat__stack_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__string_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__string_s.mli.in) (action (with-stdin-from stdcompat__string_s.mli.in (with-stdout-to stdcompat__string_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stringLabels_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__stringLabels_s.mli.in) (action (with-stdin-from stdcompat__stringLabels_s.mli.in (with-stdout-to stdcompat__stringLabels_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__sys_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__sys_s.mli.in) (action (with-stdin-from stdcompat__sys_s.mli.in (with-stdout-to stdcompat__sys_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__uchar_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__uchar_s.mli.in) (action (with-stdin-from stdcompat__uchar_s.mli.in (with-stdout-to stdcompat__uchar_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__weak_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__weak_s.mli.in) (action (with-stdin-from stdcompat__weak_s.mli.in (with-stdout-to stdcompat__weak_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__unit_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__unit_s.mli.in) (action (with-stdin-from stdcompat__unit_s.mli.in (with-stdout-to stdcompat__unit_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stdlib_s.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__stdlib_s.mli.in) (action (with-stdin-from stdcompat__stdlib_s.mli.in (with-stdout-to stdcompat__stdlib_s.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__pervasives_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__pervasives_s.mli.in) (action (with-stdin-from stdcompat__pervasives_s.mli.in (with-stdout-to stdcompat__pervasives_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arg_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__arg_s.mli.in) (action (with-stdin-from stdcompat__arg_s.mli.in (with-stdout-to stdcompat__arg_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__array_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__array_s.mli.in) (action (with-stdin-from stdcompat__array_s.mli.in (with-stdout-to stdcompat__array_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arrayLabels_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__arrayLabels_s.mli.in) (action (with-stdin-from stdcompat__arrayLabels_s.mli.in (with-stdout-to stdcompat__arrayLabels_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__atomic_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__atomic_s.mli.in) (action (with-stdin-from stdcompat__atomic_s.mli.in (with-stdout-to stdcompat__atomic_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bool_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__bool_s.mli.in) (action (with-stdin-from stdcompat__bool_s.mli.in (with-stdout-to stdcompat__bool_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__buffer_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__buffer_s.mli.in) (action (with-stdin-from stdcompat__buffer_s.mli.in (with-stdout-to stdcompat__buffer_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytes_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytes_s.mli.in) (action (with-stdin-from stdcompat__bytes_s.mli.in (with-stdout-to stdcompat__bytes_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytesLabels_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytesLabels_s.mli.in) (action (with-stdin-from stdcompat__bytesLabels_s.mli.in (with-stdout-to stdcompat__bytesLabels_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__char_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__char_s.mli.in) (action (with-stdin-from stdcompat__char_s.mli.in (with-stdout-to stdcompat__char_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__digest_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__digest_s.mli.in) (action (with-stdin-from stdcompat__digest_s.mli.in (with-stdout-to stdcompat__digest_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__domain_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__domain_s.mli.in) (action (with-stdin-from stdcompat__domain_s.mli.in (with-stdout-to stdcompat__domain_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__dynarray_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__dynarray_s.mli.in) (action (with-stdin-from stdcompat__dynarray_s.mli.in (with-stdout-to stdcompat__dynarray_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__either_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__either_s.mli.in) (action (with-stdin-from stdcompat__either_s.mli.in (with-stdout-to stdcompat__either_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__ephemeron_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__ephemeron_s.mli.in) (action (with-stdin-from stdcompat__ephemeron_s.mli.in (with-stdout-to stdcompat__ephemeron_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__filename_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__filename_s.mli.in) (action (with-stdin-from stdcompat__filename_s.mli.in (with-stdout-to stdcompat__filename_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__float_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__float_s.mli.in) (action (with-stdin-from stdcompat__float_s.mli.in (with-stdout-to stdcompat__float_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__format_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__format_s.mli.in) (action (with-stdin-from stdcompat__format_s.mli.in (with-stdout-to stdcompat__format_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__fun_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__fun_s.mli.in) (action (with-stdin-from stdcompat__fun_s.mli.in (with-stdout-to stdcompat__fun_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__hashtbl_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__hashtbl_s.mli.in) (action (with-stdin-from stdcompat__hashtbl_s.mli.in (with-stdout-to stdcompat__hashtbl_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__int_s.mli.in) (action (with-stdin-from stdcompat__int_s.mli.in (with-stdout-to stdcompat__int_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int32_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__int32_s.mli.in) (action (with-stdin-from stdcompat__int32_s.mli.in (with-stdout-to stdcompat__int32_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int64_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__int64_s.mli.in) (action (with-stdin-from stdcompat__int64_s.mli.in (with-stdout-to stdcompat__int64_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lazy_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__lazy_s.mli.in) (action (with-stdin-from stdcompat__lazy_s.mli.in (with-stdout-to stdcompat__lazy_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lexing_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__lexing_s.mli.in) (action (with-stdin-from stdcompat__lexing_s.mli.in (with-stdout-to stdcompat__lexing_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__list_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__list_s.mli.in) (action (with-stdin-from stdcompat__list_s.mli.in (with-stdout-to stdcompat__list_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__listLabels_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__listLabels_s.mli.in) (action (with-stdin-from stdcompat__listLabels_s.mli.in (with-stdout-to stdcompat__listLabels_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__map_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__map_s.mli.in) (action (with-stdin-from stdcompat__map_s.mli.in (with-stdout-to stdcompat__map_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__moreLabels_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__moreLabels_s.mli.in) (action (with-stdin-from stdcompat__moreLabels_s.mli.in (with-stdout-to stdcompat__moreLabels_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__nativeint_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__nativeint_s.mli.in) (action (with-stdin-from stdcompat__nativeint_s.mli.in (with-stdout-to stdcompat__nativeint_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__option_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__option_s.mli.in) (action (with-stdin-from stdcompat__option_s.mli.in (with-stdout-to stdcompat__option_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printexc_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__printexc_s.mli.in) (action (with-stdin-from stdcompat__printexc_s.mli.in (with-stdout-to stdcompat__printexc_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printf_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__printf_s.mli.in) (action (with-stdin-from stdcompat__printf_s.mli.in (with-stdout-to stdcompat__printf_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__queue_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__queue_s.mli.in) (action (with-stdin-from stdcompat__queue_s.mli.in (with-stdout-to stdcompat__queue_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__random_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__random_s.mli.in) (action (with-stdin-from stdcompat__random_s.mli.in (with-stdout-to stdcompat__random_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__result_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__result_s.mli.in) (action (with-stdin-from stdcompat__result_s.mli.in (with-stdout-to stdcompat__result_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__seq_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__seq_s.mli.in) (action (with-stdin-from stdcompat__seq_s.mli.in (with-stdout-to stdcompat__seq_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__set_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__set_s.mli.in) (action (with-stdin-from stdcompat__set_s.mli.in (with-stdout-to stdcompat__set_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stack_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__stack_s.mli.in) (action (with-stdin-from stdcompat__stack_s.mli.in (with-stdout-to stdcompat__stack_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stdlib_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__stdlib_s.mli.in) (action (with-stdin-from stdcompat__stdlib_s.mli.in (with-stdout-to stdcompat__stdlib_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__string_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__string_s.mli.in) (action (with-stdin-from stdcompat__string_s.mli.in (with-stdout-to stdcompat__string_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stringLabels_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__stringLabels_s.mli.in) (action (with-stdin-from stdcompat__stringLabels_s.mli.in (with-stdout-to stdcompat__stringLabels_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__sys_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__sys_s.mli.in) (action (with-stdin-from stdcompat__sys_s.mli.in (with-stdout-to stdcompat__sys_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__uchar_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__uchar_s.mli.in) (action (with-stdin-from stdcompat__uchar_s.mli.in (with-stdout-to stdcompat__uchar_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__weak_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__weak_s.mli.in) (action (with-stdin-from stdcompat__weak_s.mli.in (with-stdout-to stdcompat__weak_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__in_channel_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__in_channel_s.mli.in) (action (with-stdin-from stdcompat__in_channel_s.mli.in (with-stdout-to stdcompat__in_channel_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__out_channel_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__out_channel_s.mli.in) (action (with-stdin-from stdcompat__out_channel_s.mli.in (with-stdout-to stdcompat__out_channel_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__unit_s.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__unit_s.mli.in) (action (with-stdin-from stdcompat__unit_s.mli.in (with-stdout-to stdcompat__unit_s.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__pervasives.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__pervasives.ml.in) (action (with-stdin-from stdcompat__pervasives.ml.in (with-stdout-to stdcompat__pervasives.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arg.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__arg.ml.in) (action (with-stdin-from stdcompat__arg.ml.in (with-stdout-to stdcompat__arg.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__array.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__array.ml.in) (action (with-stdin-from stdcompat__array.ml.in (with-stdout-to stdcompat__array.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arrayLabels.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__arrayLabels.ml.in) (action (with-stdin-from stdcompat__arrayLabels.ml.in (with-stdout-to stdcompat__arrayLabels.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__atomic.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__atomic.ml.in) (action (with-stdin-from stdcompat__atomic.ml.in (with-stdout-to stdcompat__atomic.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bool.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__bool.ml.in) (action (with-stdin-from stdcompat__bool.ml.in (with-stdout-to stdcompat__bool.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__buffer.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__buffer.ml.in) (action (with-stdin-from stdcompat__buffer.ml.in (with-stdout-to stdcompat__buffer.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytes.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytes.ml.in) (action (with-stdin-from stdcompat__bytes.ml.in (with-stdout-to stdcompat__bytes.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytesLabels.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytesLabels.ml.in) (action (with-stdin-from stdcompat__bytesLabels.ml.in (with-stdout-to stdcompat__bytesLabels.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__char.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__char.ml.in) (action (with-stdin-from stdcompat__char.ml.in (with-stdout-to stdcompat__char.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__digest.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__digest.ml.in) (action (with-stdin-from stdcompat__digest.ml.in (with-stdout-to stdcompat__digest.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__domain.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__domain.ml.in) (action (with-stdin-from stdcompat__domain.ml.in (with-stdout-to stdcompat__domain.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__dynarray.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__dynarray.ml.in) (action (with-stdin-from stdcompat__dynarray.ml.in (with-stdout-to stdcompat__dynarray.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__either.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__either.ml.in) (action (with-stdin-from stdcompat__either.ml.in (with-stdout-to stdcompat__either.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__ephemeron.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__ephemeron.ml.in) (action (with-stdin-from stdcompat__ephemeron.ml.in (with-stdout-to stdcompat__ephemeron.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__filename.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__filename.ml.in) (action (with-stdin-from stdcompat__filename.ml.in (with-stdout-to stdcompat__filename.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__float.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__float.ml.in) (action (with-stdin-from stdcompat__float.ml.in (with-stdout-to stdcompat__float.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__format.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__format.ml.in) (action (with-stdin-from stdcompat__format.ml.in (with-stdout-to stdcompat__format.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__fun.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__fun.ml.in) (action (with-stdin-from stdcompat__fun.ml.in (with-stdout-to stdcompat__fun.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__hashtbl.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__hashtbl.ml.in) (action (with-stdin-from stdcompat__hashtbl.ml.in (with-stdout-to stdcompat__hashtbl.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__int.ml.in) (action (with-stdin-from stdcompat__int.ml.in (with-stdout-to stdcompat__int.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int32.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__int32.ml.in) (action (with-stdin-from stdcompat__int32.ml.in (with-stdout-to stdcompat__int32.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int64.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__int64.ml.in) (action (with-stdin-from stdcompat__int64.ml.in (with-stdout-to stdcompat__int64.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lazy.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__lazy.ml.in) (action (with-stdin-from stdcompat__lazy.ml.in (with-stdout-to stdcompat__lazy.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lexing.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__lexing.ml.in) (action (with-stdin-from stdcompat__lexing.ml.in (with-stdout-to stdcompat__lexing.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__list.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__list.ml.in) (action (with-stdin-from stdcompat__list.ml.in (with-stdout-to stdcompat__list.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__listLabels.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__listLabels.ml.in) (action (with-stdin-from stdcompat__listLabels.ml.in (with-stdout-to stdcompat__listLabels.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__map.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__map.ml.in) (action (with-stdin-from stdcompat__map.ml.in (with-stdout-to stdcompat__map.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__moreLabels.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__moreLabels.ml.in) (action (with-stdin-from stdcompat__moreLabels.ml.in (with-stdout-to stdcompat__moreLabels.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__nativeint.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__nativeint.ml.in) (action (with-stdin-from stdcompat__nativeint.ml.in (with-stdout-to stdcompat__nativeint.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__option.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__option.ml.in) (action (with-stdin-from stdcompat__option.ml.in (with-stdout-to stdcompat__option.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printexc.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__printexc.ml.in) (action (with-stdin-from stdcompat__printexc.ml.in (with-stdout-to stdcompat__printexc.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printf.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__printf.ml.in) (action (with-stdin-from stdcompat__printf.ml.in (with-stdout-to stdcompat__printf.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__queue.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__queue.ml.in) (action (with-stdin-from stdcompat__queue.ml.in (with-stdout-to stdcompat__queue.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__random.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__random.ml.in) (action (with-stdin-from stdcompat__random.ml.in (with-stdout-to stdcompat__random.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__result.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__result.ml.in) (action (with-stdin-from stdcompat__result.ml.in (with-stdout-to stdcompat__result.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__seq.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__seq.ml.in) (action (with-stdin-from stdcompat__seq.ml.in (with-stdout-to stdcompat__seq.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__set.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__set.ml.in) (action (with-stdin-from stdcompat__set.ml.in (with-stdout-to stdcompat__set.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stack.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__stack.ml.in) (action (with-stdin-from stdcompat__stack.ml.in (with-stdout-to stdcompat__stack.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stdlib.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__stdlib.ml.in) (action (with-stdin-from stdcompat__stdlib.ml.in (with-stdout-to stdcompat__stdlib.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__string.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__string.ml.in) (action (with-stdin-from stdcompat__string.ml.in (with-stdout-to stdcompat__string.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stringLabels.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__stringLabels.ml.in) (action (with-stdin-from stdcompat__stringLabels.ml.in (with-stdout-to stdcompat__stringLabels.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__sys.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__sys.ml.in) (action (with-stdin-from stdcompat__sys.ml.in (with-stdout-to stdcompat__sys.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__uchar.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__uchar.ml.in) (action (with-stdin-from stdcompat__uchar.ml.in (with-stdout-to stdcompat__uchar.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__weak.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__weak.ml.in) (action (with-stdin-from stdcompat__weak.ml.in (with-stdout-to stdcompat__weak.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__in_channel.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__in_channel.ml.in) (action (with-stdin-from stdcompat__in_channel.ml.in (with-stdout-to stdcompat__in_channel.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__out_channel.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__out_channel.ml.in) (action (with-stdin-from stdcompat__out_channel.ml.in (with-stdout-to stdcompat__out_channel.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__unit.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat__unit.ml.in) (action (with-stdin-from stdcompat__unit.ml.in (with-stdout-to stdcompat__unit.ml (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__pervasives.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__pervasives.mli.in) (action (with-stdin-from stdcompat__pervasives.mli.in (with-stdout-to stdcompat__pervasives.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arg.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__arg.mli.in) (action (with-stdin-from stdcompat__arg.mli.in (with-stdout-to stdcompat__arg.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__array.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__array.mli.in) (action (with-stdin-from stdcompat__array.mli.in (with-stdout-to stdcompat__array.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__arrayLabels.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__arrayLabels.mli.in) (action (with-stdin-from stdcompat__arrayLabels.mli.in (with-stdout-to stdcompat__arrayLabels.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__atomic.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__atomic.mli.in) (action (with-stdin-from stdcompat__atomic.mli.in (with-stdout-to stdcompat__atomic.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bool.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__bool.mli.in) (action (with-stdin-from stdcompat__bool.mli.in (with-stdout-to stdcompat__bool.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__buffer.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__buffer.mli.in) (action (with-stdin-from stdcompat__buffer.mli.in (with-stdout-to stdcompat__buffer.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytes.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytes.mli.in) (action (with-stdin-from stdcompat__bytes.mli.in (with-stdout-to stdcompat__bytes.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__bytesLabels.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__bytesLabels.mli.in) (action (with-stdin-from stdcompat__bytesLabels.mli.in (with-stdout-to stdcompat__bytesLabels.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__char.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__char.mli.in) (action (with-stdin-from stdcompat__char.mli.in (with-stdout-to stdcompat__char.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__digest.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__digest.mli.in) (action (with-stdin-from stdcompat__digest.mli.in (with-stdout-to stdcompat__digest.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__domain.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__domain.mli.in) (action (with-stdin-from stdcompat__domain.mli.in (with-stdout-to stdcompat__domain.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__dynarray.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__dynarray.mli.in) (action (with-stdin-from stdcompat__dynarray.mli.in (with-stdout-to stdcompat__dynarray.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__either.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__either.mli.in) (action (with-stdin-from stdcompat__either.mli.in (with-stdout-to stdcompat__either.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__ephemeron.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__ephemeron.mli.in) (action (with-stdin-from stdcompat__ephemeron.mli.in (with-stdout-to stdcompat__ephemeron.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__filename.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__filename.mli.in) (action (with-stdin-from stdcompat__filename.mli.in (with-stdout-to stdcompat__filename.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__float.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__float.mli.in) (action (with-stdin-from stdcompat__float.mli.in (with-stdout-to stdcompat__float.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__format.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__format.mli.in) (action (with-stdin-from stdcompat__format.mli.in (with-stdout-to stdcompat__format.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__fun.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__fun.mli.in) (action (with-stdin-from stdcompat__fun.mli.in (with-stdout-to stdcompat__fun.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__hashtbl.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__hashtbl.mli.in) (action (with-stdin-from stdcompat__hashtbl.mli.in (with-stdout-to stdcompat__hashtbl.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__int.mli.in) (action (with-stdin-from stdcompat__int.mli.in (with-stdout-to stdcompat__int.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int32.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__int32.mli.in) (action (with-stdin-from stdcompat__int32.mli.in (with-stdout-to stdcompat__int32.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__int64.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__int64.mli.in) (action (with-stdin-from stdcompat__int64.mli.in (with-stdout-to stdcompat__int64.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lazy.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__lazy.mli.in) (action (with-stdin-from stdcompat__lazy.mli.in (with-stdout-to stdcompat__lazy.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__lexing.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__lexing.mli.in) (action (with-stdin-from stdcompat__lexing.mli.in (with-stdout-to stdcompat__lexing.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__list.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__list.mli.in) (action (with-stdin-from stdcompat__list.mli.in (with-stdout-to stdcompat__list.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__listLabels.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__listLabels.mli.in) (action (with-stdin-from stdcompat__listLabels.mli.in (with-stdout-to stdcompat__listLabels.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__map.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__map.mli.in) (action (with-stdin-from stdcompat__map.mli.in (with-stdout-to stdcompat__map.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__moreLabels.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__moreLabels.mli.in) (action (with-stdin-from stdcompat__moreLabels.mli.in (with-stdout-to stdcompat__moreLabels.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__nativeint.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__nativeint.mli.in) (action (with-stdin-from stdcompat__nativeint.mli.in (with-stdout-to stdcompat__nativeint.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__option.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__option.mli.in) (action (with-stdin-from stdcompat__option.mli.in (with-stdout-to stdcompat__option.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printexc.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__printexc.mli.in) (action (with-stdin-from stdcompat__printexc.mli.in (with-stdout-to stdcompat__printexc.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__printf.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__printf.mli.in) (action (with-stdin-from stdcompat__printf.mli.in (with-stdout-to stdcompat__printf.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__queue.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__queue.mli.in) (action (with-stdin-from stdcompat__queue.mli.in (with-stdout-to stdcompat__queue.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__random.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__random.mli.in) (action (with-stdin-from stdcompat__random.mli.in (with-stdout-to stdcompat__random.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__result.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__result.mli.in) (action (with-stdin-from stdcompat__result.mli.in (with-stdout-to stdcompat__result.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__seq.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__seq.mli.in) (action (with-stdin-from stdcompat__seq.mli.in (with-stdout-to stdcompat__seq.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__set.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__set.mli.in) (action (with-stdin-from stdcompat__set.mli.in (with-stdout-to stdcompat__set.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stack.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__stack.mli.in) (action (with-stdin-from stdcompat__stack.mli.in (with-stdout-to stdcompat__stack.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stdlib.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__stdlib.mli.in) (action (with-stdin-from stdcompat__stdlib.mli.in (with-stdout-to stdcompat__stdlib.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__string.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__string.mli.in) (action (with-stdin-from stdcompat__string.mli.in (with-stdout-to stdcompat__string.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__stringLabels.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__stringLabels.mli.in) (action (with-stdin-from stdcompat__stringLabels.mli.in (with-stdout-to stdcompat__stringLabels.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__sys.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__sys.mli.in) (action (with-stdin-from stdcompat__sys.mli.in (with-stdout-to stdcompat__sys.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__uchar.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__uchar.mli.in) (action (with-stdin-from stdcompat__uchar.mli.in (with-stdout-to stdcompat__uchar.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__weak.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__weak.mli.in) (action (with-stdin-from stdcompat__weak.mli.in (with-stdout-to stdcompat__weak.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__in_channel.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__in_channel.mli.in) (action (with-stdin-from stdcompat__in_channel.mli.in (with-stdout-to stdcompat__in_channel.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__out_channel.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__out_channel.mli.in) (action (with-stdin-from stdcompat__out_channel.mli.in (with-stdout-to stdcompat__out_channel.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat__unit.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat__unit.mli.in) (action (with-stdin-from stdcompat__unit.mli.in (with-stdout-to stdcompat__unit.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat.mli) (deps (:gen tools/stdcompatpp.exe) stdcompat.mli.in) (action (with-stdin-from stdcompat.mli.in (with-stdout-to stdcompat.mli (run %{gen} --source-type ocaml))))) (rule (targets stdcompat.ml) (deps (:gen tools/stdcompatpp.exe) stdcompat.ml.in) (action (with-stdin-from stdcompat.ml.in (with-stdout-to stdcompat.ml (run %{gen} --source-type ocaml))))) stdcompat-21.1/install-sh000077500000000000000000000357761505130230400154520ustar00rootroot00000000000000#!/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: stdcompat-21.1/interfaces/000077500000000000000000000000001505130230400155475ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.07/000077500000000000000000000000001505130230400161365ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.07/arg.mli000066400000000000000000000014201505130230400174070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/array.mli000066400000000000000000000025411505130230400177610ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.07/arrayLabels.mli000066400000000000000000000027131505130230400211050ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.07/buffer.mli000066400000000000000000000006631505130230400201170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/callback.mli000066400000000000000000000001231505130230400203710ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/3.07/char.mli000066400000000000000000000003611505130230400175560ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.07/complex.mli000066400000000000000000000006021505130230400203060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/digest.mli000066400000000000000000000003741505130230400201240ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/filename.mli000066400000000000000000000010051505130230400204150ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/format.mli000066400000000000000000000126721505130230400201410ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/gc.mli000066400000000000000000000022511505130230400172320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/genlex.mli000066400000000000000000000003011505130230400201150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/hashtbl.mli000066400000000000000000000031521505130230400202670ustar00rootroot00000000000000type ('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" stdcompat-21.1/interfaces/3.07/int32.mli000066400000000000000000000023661505130230400176070ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.07/int64.mli000066400000000000000000000031521505130230400176060ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.07/lazy.mli000066400000000000000000000003041505130230400176150ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.07/lexing.mli000066400000000000000000000027231505130230400201330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/list.mli000066400000000000000000000036751505130230400176270ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/listLabels.mli000066400000000000000000000040311505130230400207350ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/map.mli000066400000000000000000000016631505130230400174240ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.07/marshal.mli000066400000000000000000000006701505130230400202730ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.07/moreLabels.mli000066400000000000000000000113271505130230400207320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.07/nativeint.mli000066400000000000000000000032411505130230400206420ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.07/obj.mli000066400000000000000000000016231505130230400174150ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/3.07/oo.mli000066400000000000000000000002631505130230400172570ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.label val public_method_label : string -> CamlinternalOO.label stdcompat-21.1/interfaces/3.07/parsing.mli000066400000000000000000000017041505130230400203060ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/pervasives.mli000066400000000000000000000163561505130230400210430ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/3.07/printexc.mli000066400000000000000000000001441505130230400204740ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-21.1/interfaces/3.07/printf.mli000066400000000000000000000007501505130230400201450ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/queue.mli000066400000000000000000000006501505130230400177660ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.07/random.mli000066400000000000000000000012701505130230400201210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/scanf.mli000066400000000000000000000014251505130230400177350ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.07/set.mli000066400000000000000000000032741505130230400174420ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.07/sort.mli000066400000000000000000000002471505130230400176330ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/stack.mli000066400000000000000000000004131505130230400177440ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.07/stdLabels.mli000066400000000000000000000116701505130230400205630ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.07/stream.mli000066400000000000000000000012611505130230400201340ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.07/string.mli000066400000000000000000000025201505130230400201460ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.07/stringLabels.mli000066400000000000000000000026001505130230400212700ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.07/sys.mli000066400000000000000000000024661505130230400174670ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.07/weak.mli000066400000000000000000000024631505130230400175750ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.08/000077500000000000000000000000001505130230400161375ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.08/arg.mli000066400000000000000000000015231505130230400174140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/array.mli000066400000000000000000000025531505130230400177650ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.08/arrayLabels.mli000066400000000000000000000027251505130230400211110ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.08/buffer.mli000066400000000000000000000007621505130230400201200ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/callback.mli000066400000000000000000000001231505130230400203720ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/3.08/char.mli000066400000000000000000000003611505130230400175570ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.08/complex.mli000066400000000000000000000006021505130230400203070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/digest.mli000066400000000000000000000004011505130230400201140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/filename.mli000066400000000000000000000010051505130230400204160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/format.mli000066400000000000000000000131331505130230400201330ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/gc.mli000066400000000000000000000024651505130230400172420ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/genlex.mli000066400000000000000000000003011505130230400201160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/hashtbl.mli000066400000000000000000000033141505130230400202700ustar00rootroot00000000000000type ('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" stdcompat-21.1/interfaces/3.08/int32.mli000066400000000000000000000026241505130230400176050ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.08/int64.mli000066400000000000000000000032101505130230400176020ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.08/lazy.mli000066400000000000000000000003041505130230400176160ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.08/lexing.mli000066400000000000000000000027231505130230400201340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/list.mli000066400000000000000000000036751505130230400176300ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/listLabels.mli000066400000000000000000000040311505130230400207360ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/map.mli000066400000000000000000000023411505130230400174170ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.08/marshal.mli000066400000000000000000000006751505130230400203010ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.08/moreLabels.mli000066400000000000000000000123411505130230400207300ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.08/nativeint.mli000066400000000000000000000032651505130230400206510ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.08/obj.mli000066400000000000000000000017351505130230400174220ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/3.08/oo.mli000066400000000000000000000002571505130230400172630ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/3.08/parsing.mli000066400000000000000000000017051505130230400203100ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/pervasives.mli000066400000000000000000000165261505130230400210430ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/3.08/printexc.mli000066400000000000000000000001441505130230400204750ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-21.1/interfaces/3.08/printf.mli000066400000000000000000000007501505130230400201460ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/queue.mli000066400000000000000000000006501505130230400177670ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.08/random.mli000066400000000000000000000012701505130230400201220ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/scanf.mli000066400000000000000000000014251505130230400177360ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.08/set.mli000066400000000000000000000034241505130230400174400ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.08/sort.mli000066400000000000000000000002471505130230400176340ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/stack.mli000066400000000000000000000004131505130230400177450ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.08/stdLabels.mli000066400000000000000000000123061505130230400205610ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.08/stream.mli000066400000000000000000000012611505130230400201350ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.08/string.mli000066400000000000000000000025431505130230400201540ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.08/stringLabels.mli000066400000000000000000000026731505130230400213030ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.08/sys.mli000066400000000000000000000025501505130230400174620ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.08/weak.mli000066400000000000000000000024651505130230400176000ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.09/000077500000000000000000000000001505130230400161405ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.09/arg.mli000066400000000000000000000015231505130230400174150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/array.mli000066400000000000000000000025531505130230400177660ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.09/arrayLabels.mli000066400000000000000000000027251505130230400211120ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.09/buffer.mli000066400000000000000000000007621505130230400201210ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/callback.mli000066400000000000000000000001231505130230400203730ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/3.09/char.mli000066400000000000000000000003611505130230400175600ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.09/complex.mli000066400000000000000000000006021505130230400203100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/digest.mli000066400000000000000000000004011505130230400201150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/filename.mli000066400000000000000000000010401505130230400204160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/format.mli000066400000000000000000000131331505130230400201340ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/gc.mli000066400000000000000000000024651505130230400172430ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/genlex.mli000066400000000000000000000003011505130230400201170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/hashtbl.mli000066400000000000000000000033141505130230400202710ustar00rootroot00000000000000type ('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" stdcompat-21.1/interfaces/3.09/int32.mli000066400000000000000000000026241505130230400176060ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.09/int64.mli000066400000000000000000000032101505130230400176030ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.09/lazy.mli000066400000000000000000000003041505130230400176170ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.09/lexing.mli000066400000000000000000000027231505130230400201350ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/list.mli000066400000000000000000000036751505130230400176310ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/listLabels.mli000066400000000000000000000040311505130230400207370ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/map.mli000066400000000000000000000023411505130230400174200ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.09/marshal.mli000066400000000000000000000006751505130230400203020ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.09/moreLabels.mli000066400000000000000000000123411505130230400207310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.09/nativeint.mli000066400000000000000000000032651505130230400206520ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.09/obj.mli000066400000000000000000000017351505130230400174230ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/3.09/oo.mli000066400000000000000000000002571505130230400172640ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/3.09/parsing.mli000066400000000000000000000017051505130230400203110ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/pervasives.mli000066400000000000000000000165261505130230400210440ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/3.09/printexc.mli000066400000000000000000000001441505130230400204760ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-21.1/interfaces/3.09/printf.mli000066400000000000000000000021231505130230400201430ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/queue.mli000066400000000000000000000006501505130230400177700ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.09/random.mli000066400000000000000000000012701505130230400201230ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/scanf.mli000066400000000000000000000020031505130230400177300ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.09/set.mli000066400000000000000000000034241505130230400174410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.09/sort.mli000066400000000000000000000002471505130230400176350ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/stack.mli000066400000000000000000000004131505130230400177460ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.09/stdLabels.mli000066400000000000000000000123061505130230400205620ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.09/stream.mli000066400000000000000000000012611505130230400201360ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.09/string.mli000066400000000000000000000025431505130230400201550ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.09/stringLabels.mli000066400000000000000000000026731505130230400213040ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.09/sys.mli000066400000000000000000000025501505130230400174630ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.09/weak.mli000066400000000000000000000024651505130230400176010ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.10/000077500000000000000000000000001505130230400161305ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.10/arg.mli000066400000000000000000000015231505130230400174050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/array.mli000066400000000000000000000025531505130230400177560ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.10/arrayLabels.mli000066400000000000000000000027251505130230400211020ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.10/buffer.mli000066400000000000000000000007621505130230400201110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/callback.mli000066400000000000000000000001231505130230400203630ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/3.10/char.mli000066400000000000000000000003611505130230400175500ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.10/complex.mli000066400000000000000000000006021505130230400203000ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/digest.mli000066400000000000000000000004011505130230400201050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/filename.mli000066400000000000000000000010401505130230400204060ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/format.mli000066400000000000000000000132321505130230400201240ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/gc.mli000066400000000000000000000024651505130230400172330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/genlex.mli000066400000000000000000000003011505130230400201070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/hashtbl.mli000066400000000000000000000033141505130230400202610ustar00rootroot00000000000000type ('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" stdcompat-21.1/interfaces/3.10/int32.mli000066400000000000000000000026241505130230400175760ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.10/int64.mli000066400000000000000000000032101505130230400175730ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.10/lazy.mli000066400000000000000000000003041505130230400176070ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.10/lexing.mli000066400000000000000000000027231505130230400201250ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/list.mli000066400000000000000000000036751505130230400176210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/listLabels.mli000066400000000000000000000040311505130230400207270ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/map.mli000066400000000000000000000023411505130230400174100ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.10/marshal.mli000066400000000000000000000006751505130230400202720ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.10/moreLabels.mli000066400000000000000000000123411505130230400207210ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.10/nativeint.mli000066400000000000000000000032651505130230400206420ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.10/obj.mli000066400000000000000000000017351505130230400174130ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/3.10/oo.mli000066400000000000000000000002571505130230400172540ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/3.10/parsing.mli000066400000000000000000000017051505130230400203010ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/pervasives.mli000066400000000000000000000167131505130230400210320ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/3.10/printexc.mli000066400000000000000000000001441505130230400204660ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-21.1/interfaces/3.10/printf.mli000066400000000000000000000047511505130230400201440ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/queue.mli000066400000000000000000000006501505130230400177600ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.10/random.mli000066400000000000000000000012701505130230400201130ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/scanf.mli000066400000000000000000000022331505130230400177250ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.10/set.mli000066400000000000000000000034241505130230400174310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.10/sort.mli000066400000000000000000000002471505130230400176250ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/stack.mli000066400000000000000000000004131505130230400177360ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.10/stdLabels.mli000066400000000000000000000123061505130230400205520ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.10/stream.mli000066400000000000000000000012611505130230400201260ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.10/string.mli000066400000000000000000000025431505130230400201450ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.10/stringLabels.mli000066400000000000000000000026731505130230400212740ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.10/sys.mli000066400000000000000000000026511505130230400174550ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.10/weak.mli000066400000000000000000000024651505130230400175710ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.11/000077500000000000000000000000001505130230400161315ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.11/arg.mli000066400000000000000000000015231505130230400174060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/array.mli000066400000000000000000000025531505130230400177570ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.11/arrayLabels.mli000066400000000000000000000027251505130230400211030ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.11/buffer.mli000066400000000000000000000010461505130230400201060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/callback.mli000066400000000000000000000001231505130230400203640ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/3.11/char.mli000066400000000000000000000003611505130230400175510ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.11/complex.mli000066400000000000000000000006021505130230400203010ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/digest.mli000066400000000000000000000004011505130230400201060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/filename.mli000066400000000000000000000011411505130230400204110ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/format.mli000066400000000000000000000132321505130230400201250ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/gc.mli000066400000000000000000000025301505130230400172250ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/genlex.mli000066400000000000000000000003011505130230400201100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/hashtbl.mli000066400000000000000000000033141505130230400202620ustar00rootroot00000000000000type ('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" stdcompat-21.1/interfaces/3.11/int32.mli000066400000000000000000000026241505130230400175770ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.11/int64.mli000066400000000000000000000032101505130230400175740ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.11/lazy.mli000066400000000000000000000003311505130230400176100ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.11/lexing.mli000066400000000000000000000027611505130230400201300ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/list.mli000066400000000000000000000036751505130230400176220ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/listLabels.mli000066400000000000000000000040311505130230400207300ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/map.mli000066400000000000000000000023411505130230400174110ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.11/marshal.mli000066400000000000000000000006751505130230400202730ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.11/moreLabels.mli000066400000000000000000000123411505130230400207220ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.11/nativeint.mli000066400000000000000000000032651505130230400206430ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.11/obj.mli000066400000000000000000000022071505130230400174070ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/3.11/oo.mli000066400000000000000000000002571505130230400172550ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/3.11/parsing.mli000066400000000000000000000017421505130230400203030ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/pervasives.mli000066400000000000000000000167131505130230400210330ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/3.11/printexc.mli000066400000000000000000000004571505130230400204760ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/printf.mli000066400000000000000000000047511505130230400201450ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/queue.mli000066400000000000000000000006501505130230400177610ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.11/random.mli000066400000000000000000000012701505130230400201140ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/scanf.mli000066400000000000000000000022331505130230400177260ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.11/set.mli000066400000000000000000000034241505130230400174320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.11/sort.mli000066400000000000000000000002471505130230400176260ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/stack.mli000066400000000000000000000004131505130230400177370ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.11/stdLabels.mli000066400000000000000000000123061505130230400205530ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.11/stream.mli000066400000000000000000000012611505130230400201270ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.11/string.mli000066400000000000000000000025431505130230400201460ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.11/stringLabels.mli000066400000000000000000000026731505130230400212750ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.11/sys.mli000066400000000000000000000026511505130230400174560ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.11/weak.mli000066400000000000000000000024651505130230400175720ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.12/000077500000000000000000000000001505130230400161325ustar00rootroot00000000000000stdcompat-21.1/interfaces/3.12/arg.mli000066400000000000000000000016251505130230400174120ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/array.mli000066400000000000000000000025531505130230400177600ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.12/arrayLabels.mli000066400000000000000000000027251505130230400211040ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.12/buffer.mli000066400000000000000000000010461505130230400201070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/callback.mli000066400000000000000000000001231505130230400203650ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/3.12/char.mli000066400000000000000000000003611505130230400175520ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.12/complex.mli000066400000000000000000000006021505130230400203020ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/digest.mli000066400000000000000000000004011505130230400201070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/filename.mli000066400000000000000000000011411505130230400204120ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/format.mli000066400000000000000000000133661505130230400201360ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/gc.mli000066400000000000000000000025541505130230400172340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/genlex.mli000066400000000000000000000003011505130230400201110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/hashtbl.mli000066400000000000000000000033141505130230400202630ustar00rootroot00000000000000type ('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" stdcompat-21.1/interfaces/3.12/int32.mli000066400000000000000000000026241505130230400176000ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.12/int64.mli000066400000000000000000000032101505130230400175750ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.12/lazy.mli000066400000000000000000000003311505130230400176110ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.12/lexing.mli000066400000000000000000000027611505130230400201310ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/list.mli000066400000000000000000000036751505130230400176230ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/listLabels.mli000066400000000000000000000040311505130230400207310ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/map.mli000066400000000000000000000046271505130230400174230ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.12/marshal.mli000066400000000000000000000006751505130230400202740ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/3.12/moreLabels.mli000066400000000000000000000147631505130230400207350ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.12/nativeint.mli000066400000000000000000000032651505130230400206440ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/3.12/obj.mli000066400000000000000000000022131505130230400174050ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/3.12/oo.mli000066400000000000000000000002571505130230400172560ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/3.12/parsing.mli000066400000000000000000000017421505130230400203040ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/pervasives.mli000066400000000000000000000172661505130230400210400ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/3.12/printexc.mli000066400000000000000000000004571505130230400204770ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/printf.mli000066400000000000000000000047511505130230400201460ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/queue.mli000066400000000000000000000006501505130230400177620ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.12/random.mli000066400000000000000000000012701505130230400201150ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/scanf.mli000066400000000000000000000025571505130230400177400ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.12/set.mli000066400000000000000000000034241505130230400174330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.12/sort.mli000066400000000000000000000002471505130230400176270ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/stack.mli000066400000000000000000000004131505130230400177400ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.12/stdLabels.mli000066400000000000000000000123061505130230400205540ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/3.12/stream.mli000066400000000000000000000012611505130230400201300ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/3.12/string.mli000066400000000000000000000025431505130230400201470ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.12/stringLabels.mli000066400000000000000000000026731505130230400212760ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/3.12/sys.mli000066400000000000000000000026511505130230400174570ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/3.12/weak.mli000066400000000000000000000024651505130230400175730ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.00/000077500000000000000000000000001505130230400161305ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.00/arg.mli000066400000000000000000000016251505130230400174100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/array.mli000066400000000000000000000025531505130230400177560ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.00/arrayLabels.mli000066400000000000000000000027251505130230400211020ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.00/buffer.mli000066400000000000000000000010461505130230400201050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/callback.mli000066400000000000000000000001231505130230400203630ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.00/char.mli000066400000000000000000000003611505130230400175500ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.00/complex.mli000066400000000000000000000006021505130230400203000ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/digest.mli000066400000000000000000000004701505130230400201130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/filename.mli000066400000000000000000000012571505130230400204200ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/format.mli000066400000000000000000000133661505130230400201340ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/gc.mli000066400000000000000000000025541505130230400172320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/genlex.mli000066400000000000000000000003011505130230400201070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/hashtbl.mli000066400000000000000000000066371505130230400202740ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.00/int32.mli000066400000000000000000000026241505130230400175760ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.00/int64.mli000066400000000000000000000032101505130230400175730ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.00/lazy.mli000066400000000000000000000004611505130230400176130ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.00/lexing.mli000066400000000000000000000027611505130230400201270ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/list.mli000066400000000000000000000040431505130230400176070ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/listLabels.mli000066400000000000000000000042031505130230400207300ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/map.mli000066400000000000000000000046271505130230400174210ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.00/marshal.mli000066400000000000000000000006751505130230400202720ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.00/moreLabels.mli000066400000000000000000000203731505130230400207250ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.00/nativeint.mli000066400000000000000000000032651505130230400206420ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.00/obj.mli000066400000000000000000000022131505130230400174030ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/4.00/oo.mli000066400000000000000000000002571505130230400172540ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.00/parsing.mli000066400000000000000000000017421505130230400203020ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/pervasives.mli000066400000000000000000000175511505130230400210330ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.00/printexc.mli000066400000000000000000000004571505130230400204750ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/printf.mli000066400000000000000000000047511505130230400201440ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/queue.mli000066400000000000000000000006501505130230400177600ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.00/random.mli000066400000000000000000000012701505130230400201130ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/scanf.mli000066400000000000000000000026631505130230400177340ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.00/set.mli000066400000000000000000000034241505130230400174310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.00/sort.mli000066400000000000000000000002471505130230400176250ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/stack.mli000066400000000000000000000004131505130230400177360ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.00/stdLabels.mli000066400000000000000000000125151505130230400205540ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.00/stream.mli000066400000000000000000000012611505130230400201260ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.00/string.mli000066400000000000000000000027401505130230400201440ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.00/stringLabels.mli000066400000000000000000000030741505130230400212700ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.00/sys.mli000066400000000000000000000026771505130230400174650ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.00/weak.mli000066400000000000000000000024651505130230400175710ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.01/000077500000000000000000000000001505130230400161315ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.01/arg.mli000066400000000000000000000021641505130230400174100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/array.mli000066400000000000000000000025531505130230400177570ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.01/arrayLabels.mli000066400000000000000000000027251505130230400211030ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.01/buffer.mli000066400000000000000000000010461505130230400201060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/callback.mli000066400000000000000000000001231505130230400203640ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.01/char.mli000066400000000000000000000003611505130230400175510ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.01/complex.mli000066400000000000000000000006021505130230400203010ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/digest.mli000066400000000000000000000004701505130230400201140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/filename.mli000066400000000000000000000012571505130230400204210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/format.mli000066400000000000000000000144031505130230400201260ustar00rootroot00000000000000val 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)) stdcompat-21.1/interfaces/4.01/gc.mli000066400000000000000000000025541505130230400172330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/genlex.mli000066400000000000000000000003011505130230400201100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/hashtbl.mli000066400000000000000000000066371505130230400202750ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.01/int32.mli000066400000000000000000000026241505130230400175770ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.01/int64.mli000066400000000000000000000032101505130230400175740ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.01/lazy.mli000066400000000000000000000004611505130230400176140ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.01/lexing.mli000066400000000000000000000027611505130230400201300ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/list.mli000066400000000000000000000040431505130230400176100ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/listLabels.mli000066400000000000000000000042031505130230400207310ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/map.mli000066400000000000000000000046271505130230400174220ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.01/marshal.mli000066400000000000000000000007141505130230400202650ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.01/moreLabels.mli000066400000000000000000000204751505130230400207310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.01/nativeint.mli000066400000000000000000000032651505130230400206430ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.01/obj.mli000066400000000000000000000022131505130230400174040ustar00rootroot00000000000000type 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) stdcompat-21.1/interfaces/4.01/oo.mli000066400000000000000000000002571505130230400172550ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.01/parsing.mli000066400000000000000000000017421505130230400203030ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/pervasives.mli000066400000000000000000000177201505130230400210320ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.01/printexc.mli000066400000000000000000000010161505130230400204660ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/printf.mli000066400000000000000000000053301505130230400201370ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/queue.mli000066400000000000000000000006501505130230400177610ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.01/random.mli000066400000000000000000000012701505130230400201140ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/scanf.mli000066400000000000000000000026631505130230400177350ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.01/set.mli000066400000000000000000000035221505130230400174310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.01/sort.mli000066400000000000000000000002471505130230400176260ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/stack.mli000066400000000000000000000004131505130230400177370ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.01/stdLabels.mli000066400000000000000000000125151505130230400205550ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.01/stream.mli000066400000000000000000000012611505130230400201270ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.01/string.mli000066400000000000000000000027401505130230400201450ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.01/stringLabels.mli000066400000000000000000000030741505130230400212710ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.01/sys.mli000066400000000000000000000027621505130230400174610ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.01/weak.mli000066400000000000000000000024651505130230400175720ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.02/000077500000000000000000000000001505130230400161325ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.02/arg.mli000066400000000000000000000021631505130230400174100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/array.mli000066400000000000000000000032041505130230400177520ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.02/arrayLabels.mli000066400000000000000000000033021505130230400210740ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.02/buffer.mli000066400000000000000000000012261505130230400201070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/bytes.mli000066400000000000000000000035461505130230400177730ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.02/bytesLabels.mli000066400000000000000000000034771505130230400211210ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.02/callback.mli000066400000000000000000000001231505130230400203650ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.02/char.mli000066400000000000000000000003611505130230400175520ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.02/complex.mli000066400000000000000000000006021505130230400203020ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/digest.mli000066400000000000000000000005671505130230400201240ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/filename.mli000066400000000000000000000014101505130230400204110ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/format.mli000066400000000000000000000162051505130230400201310ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.02/gc.mli000066400000000000000000000025541505130230400172340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/genlex.mli000066400000000000000000000003011505130230400201110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/hashtbl.mli000066400000000000000000000066371505130230400202760ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.02/int32.mli000066400000000000000000000026241505130230400176000ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.02/int64.mli000066400000000000000000000032101505130230400175750ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.02/lazy.mli000066400000000000000000000010141505130230400176100ustar00rootroot00000000000000type '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."] stdcompat-21.1/interfaces/4.02/lexing.mli000066400000000000000000000027571505130230400201360ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/list.mli000066400000000000000000000041331505130230400176110ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/listLabels.mli000066400000000000000000000042031505130230400207320ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/map.mli000066400000000000000000000046301505130230400174150ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.02/marshal.mli000066400000000000000000000011041505130230400202600ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.02/moreLabels.mli000066400000000000000000000206021505130230400207220ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.02/nativeint.mli000066400000000000000000000032651505130230400206440ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.02/obj.mli000066400000000000000000000030301505130230400174030ustar00rootroot00000000000000type 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."] stdcompat-21.1/interfaces/4.02/oo.mli000066400000000000000000000002571505130230400172560ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.02/parsing.mli000066400000000000000000000017421505130230400203040ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/pervasives.mli000066400000000000000000000216311505130230400210270ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.02/printexc.mli000066400000000000000000000023041505130230400204700ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/printf.mli000066400000000000000000000013601505130230400201370ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/queue.mli000066400000000000000000000006501505130230400177620ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.02/random.mli000066400000000000000000000012701505130230400201150ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/scanf.mli000066400000000000000000000031551505130230400177330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.02/set.mli000066400000000000000000000036221505130230400174330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.02/sort.mli000066400000000000000000000007321505130230400176260ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.02/stack.mli000066400000000000000000000004131505130230400177400ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.02/stdLabels.mli000066400000000000000000000167171505130230400205660ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.02/stream.mli000066400000000000000000000013201505130230400201240ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.02/string.mli000066400000000000000000000042021505130230400201410ustar00rootroot00000000000000external 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 = "] stdcompat-21.1/interfaces/4.02/stringLabels.mli000066400000000000000000000041671505130230400212760ustar00rootroot00000000000000external 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 = "] stdcompat-21.1/interfaces/4.02/sys.mli000066400000000000000000000027621505130230400174620ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.02/weak.mli000066400000000000000000000024651505130230400175730ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.03/000077500000000000000000000000001505130230400161335ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.03/arg.mli000066400000000000000000000021631505130230400174110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/array.mli000066400000000000000000000040441505130230400177560ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.03/arrayLabels.mli000066400000000000000000000040671505130230400211060ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.03/buffer.mli000066400000000000000000000012261505130230400201100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/bytes.mli000066400000000000000000000047151505130230400177730ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.03/bytesLabels.mli000066400000000000000000000036071505130230400211150ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.03/callback.mli000066400000000000000000000001231505130230400203660ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.03/char.mli000066400000000000000000000007761505130230400175650ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.03/complex.mli000066400000000000000000000006021505130230400203030ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/digest.mli000066400000000000000000000006221505130230400201150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/ephemeron.mli000066400000000000000000000237231505130230400206270ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.03/filename.mli000066400000000000000000000014341505130230400204200ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/format.mli000066400000000000000000000203711505130230400201310ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.03/gc.mli000066400000000000000000000032451505130230400172330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/genlex.mli000066400000000000000000000003011505130230400201120ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/hashtbl.mli000066400000000000000000000074371505130230400202760ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.03/int32.mli000066400000000000000000000032431505130230400175770ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.03/int64.mli000066400000000000000000000036271505130230400176120ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.03/lazy.mli000066400000000000000000000010141505130230400176110ustar00rootroot00000000000000type '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."] stdcompat-21.1/interfaces/4.03/lexing.mli000066400000000000000000000027571505130230400201370ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/list.mli000066400000000000000000000041771505130230400176220ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/listLabels.mli000066400000000000000000000042771505130230400207460ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/map.mli000066400000000000000000000050461505130230400174200ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.03/marshal.mli000066400000000000000000000011041505130230400202610ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/moreLabels.mli000066400000000000000000000217341505130230400207320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.03/nativeint.mli000066400000000000000000000035201505130230400206370ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.03/obj.mli000066400000000000000000000042041505130230400174100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/oo.mli000066400000000000000000000002571505130230400172570ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.03/parsing.mli000066400000000000000000000017421505130230400203050ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/pervasives.mli000066400000000000000000000235561505130230400210400ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.03/printexc.mli000066400000000000000000000023041505130230400204710ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/printf.mli000066400000000000000000000013221505130230400201360ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/queue.mli000066400000000000000000000006501505130230400177630ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.03/random.mli000066400000000000000000000012701505130230400201160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.03/scanf.mli000066400000000000000000000035541505130230400177370ustar00rootroot00000000000000module 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."] stdcompat-21.1/interfaces/4.03/set.mli000066400000000000000000000036221505130230400174340ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.03/sort.mli000066400000000000000000000007321505130230400176270ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.03/stack.mli000066400000000000000000000004731505130230400177470ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.03/stdLabels.mli000066400000000000000000000176611505130230400205660ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.03/stream.mli000066400000000000000000000013201505130230400201250ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.03/string.mli000066400000000000000000000053661505130230400201560ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.03/stringLabels.mli000066400000000000000000000042751505130230400212770ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.03/sys.mli000066400000000000000000000037111505130230400174560ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.03/uchar.mli000066400000000000000000000006021505130230400177360ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.03/weak.mli000066400000000000000000000024651505130230400175740ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.04/000077500000000000000000000000001505130230400161345ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.04/arg.mli000066400000000000000000000021631505130230400174120ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/array.mli000066400000000000000000000040441505130230400177570ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.04/arrayLabels.mli000066400000000000000000000040671505130230400211070ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.04/buffer.mli000066400000000000000000000012261505130230400201110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/bytes.mli000066400000000000000000000046011505130230400177660ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.04/bytesLabels.mli000066400000000000000000000034731505130230400211170ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.04/callback.mli000066400000000000000000000001231505130230400203670ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.04/char.mli000066400000000000000000000007761505130230400175660ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.04/complex.mli000066400000000000000000000006021505130230400203040ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/digest.mli000066400000000000000000000006221505130230400201160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/ephemeron.mli000066400000000000000000000237231505130230400206300ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.04/filename.mli000066400000000000000000000015451505130230400204240ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/format.mli000066400000000000000000000204441505130230400201330ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.04/gc.mli000066400000000000000000000035221505130230400172320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/genlex.mli000066400000000000000000000003011505130230400201130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/hashtbl.mli000066400000000000000000000074371505130230400202770ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.04/int32.mli000066400000000000000000000032431505130230400176000ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.04/int64.mli000066400000000000000000000036271505130230400176130ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.04/lazy.mli000066400000000000000000000010141505130230400176120ustar00rootroot00000000000000type '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."] stdcompat-21.1/interfaces/4.04/lexing.mli000066400000000000000000000027571505130230400201400ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/list.mli000066400000000000000000000041771505130230400176230ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/listLabels.mli000066400000000000000000000042771505130230400207470ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/map.mli000066400000000000000000000050461505130230400174210ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.04/marshal.mli000066400000000000000000000011041505130230400202620ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/moreLabels.mli000066400000000000000000000220561505130230400207310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.04/nativeint.mli000066400000000000000000000035201505130230400206400ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.04/obj.mli000066400000000000000000000042521505130230400174140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/oo.mli000066400000000000000000000002571505130230400172600ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.04/parsing.mli000066400000000000000000000017421505130230400203060ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/pervasives.mli000066400000000000000000000235561505130230400210410ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.04/printexc.mli000066400000000000000000000024641505130230400205010ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/printf.mli000066400000000000000000000013221505130230400201370ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/queue.mli000066400000000000000000000006501505130230400177640ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.04/random.mli000066400000000000000000000012701505130230400201170ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.04/scanf.mli000066400000000000000000000035541505130230400177400ustar00rootroot00000000000000module 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."] stdcompat-21.1/interfaces/4.04/set.mli000066400000000000000000000037341505130230400174410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.04/sort.mli000066400000000000000000000007321505130230400176300ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.04/spacetime.mli000066400000000000000000000004721505130230400206140ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.04/stack.mli000066400000000000000000000004731505130230400177500ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.04/stdLabels.mli000066400000000000000000000176511505130230400205660ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.04/stream.mli000066400000000000000000000013201505130230400201260ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.04/string.mli000066400000000000000000000054501505130230400201510ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.04/stringLabels.mli000066400000000000000000000042751505130230400213000ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.04/sys.mli000066400000000000000000000040541505130230400174600ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.04/uchar.mli000066400000000000000000000006021505130230400177370ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.04/weak.mli000066400000000000000000000024651505130230400175750ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.05/000077500000000000000000000000001505130230400161355ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.05/arg.mli000066400000000000000000000030341505130230400174110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/array.mli000066400000000000000000000040441505130230400177600ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.05/arrayLabels.mli000066400000000000000000000042501505130230400211020ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.05/buffer.mli000066400000000000000000000012661505130230400201160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/bytes.mli000066400000000000000000000051131505130230400177660ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.05/bytesLabels.mli000066400000000000000000000053301505130230400211120ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.05/callback.mli000066400000000000000000000001231505130230400203700ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.05/char.mli000066400000000000000000000007761505130230400175670ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.05/complex.mli000066400000000000000000000006021505130230400203050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/digest.mli000066400000000000000000000006221505130230400201170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/ephemeron.mli000066400000000000000000000245611505130230400206320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.05/filename.mli000066400000000000000000000015451505130230400204250ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/format.mli000066400000000000000000000204441505130230400201340ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.05/gc.mli000066400000000000000000000034721505130230400172370ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/genlex.mli000066400000000000000000000003011505130230400201140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/hashtbl.mli000066400000000000000000000077741505130230400203040ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.05/int32.mli000066400000000000000000000033161505130230400176020ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.05/int64.mli000066400000000000000000000037021505130230400176060ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.05/lazy.mli000066400000000000000000000010141505130230400176130ustar00rootroot00000000000000type '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."] stdcompat-21.1/interfaces/4.05/lexing.mli000066400000000000000000000027571505130230400201410ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/list.mli000066400000000000000000000046401505130230400176170ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/listLabels.mli000066400000000000000000000050121505130230400207340ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/map.mli000066400000000000000000000066341505130230400174260ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.05/marshal.mli000066400000000000000000000011041505130230400202630ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/moreLabels.mli000066400000000000000000000257441505130230400207410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.05/nativeint.mli000066400000000000000000000035771505130230400206550ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.05/obj.mli000066400000000000000000000042521505130230400174150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/oo.mli000066400000000000000000000002571505130230400172610ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.05/parsing.mli000066400000000000000000000017421505130230400203070ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/pervasives.mli000066400000000000000000000241131505130230400210300ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.05/printexc.mli000066400000000000000000000026131505130230400204760ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/printf.mli000066400000000000000000000013221505130230400201400ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/queue.mli000066400000000000000000000006501505130230400177650ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.05/random.mli000066400000000000000000000012701505130230400201200ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/scanf.mli000066400000000000000000000035541505130230400177410ustar00rootroot00000000000000module 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."] stdcompat-21.1/interfaces/4.05/set.mli000066400000000000000000000052621505130230400174400ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.05/sort.mli000066400000000000000000000007321505130230400176310ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.05/spacetime.mli000066400000000000000000000005151505130230400206130ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.05/stack.mli000066400000000000000000000004731505130230400177510ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.05/stdLabels.mli000066400000000000000000000226471505130230400205700ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.05/stream.mli000066400000000000000000000013201505130230400201270ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.05/string.mli000066400000000000000000000057661505130230400201640ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.05/stringLabels.mli000066400000000000000000000057641505130230400213050ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.05/sys.mli000066400000000000000000000041251505130230400174600ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.05/uchar.mli000066400000000000000000000005311505130230400177410ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.05/weak.mli000066400000000000000000000026151505130230400175730ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.06/000077500000000000000000000000001505130230400161365ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.06/arg.mli000066400000000000000000000030341505130230400174120ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/array.mli000066400000000000000000000047701505130230400177670ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.06/arrayLabels.mli000066400000000000000000000051741505130230400211110ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.06/buffer.mli000066400000000000000000000014751505130230400201210ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/bytes.mli000066400000000000000000000051131505130230400177670ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.06/bytesLabels.mli000066400000000000000000000053401505130230400211140ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.06/callback.mli000066400000000000000000000001231505130230400203710ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.06/char.mli000066400000000000000000000007761505130230400175700ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.06/complex.mli000066400000000000000000000006021505130230400203060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/digest.mli000066400000000000000000000006221505130230400201200ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/ephemeron.mli000066400000000000000000000245611505130230400206330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.06/filename.mli000066400000000000000000000015451505130230400204260ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/format.mli000066400000000000000000000176711505130230400201450ustar00rootroot00000000000000type 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."] stdcompat-21.1/interfaces/4.06/gc.mli000066400000000000000000000034721505130230400172400ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/genlex.mli000066400000000000000000000003011505130230400201150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/hashtbl.mli000066400000000000000000000077741505130230400203050ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.06/int32.mli000066400000000000000000000033161505130230400176030ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.06/int64.mli000066400000000000000000000037021505130230400176070ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.06/lazy.mli000066400000000000000000000010141505130230400176140ustar00rootroot00000000000000type '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."] stdcompat-21.1/interfaces/4.06/lexing.mli000066400000000000000000000027571505130230400201420ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/list.mli000066400000000000000000000047111505130230400176170ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/listLabels.mli000066400000000000000000000050711505130230400207420ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/map.mli000066400000000000000000000070361505130230400174240ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.06/marshal.mli000066400000000000000000000011041505130230400202640ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/moreLabels.mli000066400000000000000000000261661505130230400207410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.06/nativeint.mli000066400000000000000000000035771505130230400206560ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.06/obj.mli000066400000000000000000000042521505130230400174160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/oo.mli000066400000000000000000000002571505130230400172620ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.06/parsing.mli000066400000000000000000000017421505130230400203100ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/pervasives.mli000066400000000000000000000241131505130230400210310ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.06/printexc.mli000066400000000000000000000026131505130230400204770ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/printf.mli000066400000000000000000000013221505130230400201410ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/queue.mli000066400000000000000000000006501505130230400177660ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.06/random.mli000066400000000000000000000012701505130230400201210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/scanf.mli000066400000000000000000000035671505130230400177460ustar00rootroot00000000000000module 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."] stdcompat-21.1/interfaces/4.06/set.mli000066400000000000000000000052621505130230400174410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.06/sort.mli000066400000000000000000000007321505130230400176320ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.06/spacetime.mli000066400000000000000000000005151505130230400206140ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.06/stack.mli000066400000000000000000000004731505130230400177520ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.06/stdLabels.mli000066400000000000000000000237241505130230400205660ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.06/stream.mli000066400000000000000000000013201505130230400201300ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.06/string.mli000066400000000000000000000057661505130230400201650ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.06/stringLabels.mli000066400000000000000000000061041505130230400212730ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.06/sys.mli000066400000000000000000000041251505130230400174610ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.06/uchar.mli000066400000000000000000000005611505130230400177450ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.06/weak.mli000066400000000000000000000026151505130230400175740ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.07/000077500000000000000000000000001505130230400161375ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.07/arg.mli000066400000000000000000000030341505130230400174130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/array.mli000066400000000000000000000051471505130230400177670ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.07/arrayLabels.mli000066400000000000000000000053531505130230400211110ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.07/buffer.mli000066400000000000000000000017031505130230400201140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/bytes.mli000066400000000000000000000052531505130230400177750ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.07/bytesLabels.mli000066400000000000000000000055001505130230400211130ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.07/callback.mli000066400000000000000000000001231505130230400203720ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.07/char.mli000066400000000000000000000007761505130230400175710ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.07/complex.mli000066400000000000000000000006021505130230400203070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/digest.mli000066400000000000000000000006221505130230400201210ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/ephemeron.mli000066400000000000000000000315441505130230400206330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.07/filename.mli000066400000000000000000000015451505130230400204270ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/float.mli000066400000000000000000000075351505130230400177610ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.07/format.mli000066400000000000000000000176711505130230400201460ustar00rootroot00000000000000type 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."] stdcompat-21.1/interfaces/4.07/gc.mli000066400000000000000000000034721505130230400172410ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/genlex.mli000066400000000000000000000003011505130230400201160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/hashtbl.mli000066400000000000000000000125161505130230400202740ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.07/int32.mli000066400000000000000000000033161505130230400176040ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.07/int64.mli000066400000000000000000000037021505130230400176100ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.07/lazy.mli000066400000000000000000000010141505130230400176150ustar00rootroot00000000000000type '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."] stdcompat-21.1/interfaces/4.07/lexing.mli000066400000000000000000000027571505130230400201430ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/list.mli000066400000000000000000000050131505130230400176140ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/listLabels.mli000066400000000000000000000051731505130230400207460ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/map.mli000066400000000000000000000076301505130230400174250ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.07/marshal.mli000066400000000000000000000011031505130230400202640ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/moreLabels.mli000066400000000000000000000324341505130230400207350ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.07/nativeint.mli000066400000000000000000000035771505130230400206570ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.07/obj.mli000066400000000000000000000042521505130230400174170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/oo.mli000066400000000000000000000002571505130230400172630ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.07/parsing.mli000066400000000000000000000017421505130230400203110ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/pervasives.mli000066400000000000000000000241131505130230400210320ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.07/printexc.mli000066400000000000000000000026131505130230400205000ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/printf.mli000066400000000000000000000013221505130230400201420ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/queue.mli000066400000000000000000000010131505130230400177610ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.07/random.mli000066400000000000000000000012701505130230400201220ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/scanf.mli000066400000000000000000000035671505130230400177470ustar00rootroot00000000000000module 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."] stdcompat-21.1/interfaces/4.07/seq.mli000066400000000000000000000005761505130230400174420ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.07/set.mli000066400000000000000000000057261505130230400174470ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.07/sort.mli000066400000000000000000000007321505130230400176330ustar00rootroot00000000000000val 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."] stdcompat-21.1/interfaces/4.07/spacetime.mli000066400000000000000000000005151505130230400206150ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.07/stack.mli000066400000000000000000000006361505130230400177540ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.07/stdLabels.mli000066400000000000000000000001541505130230400205570ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.07/stream.mli000066400000000000000000000013201505130230400201310ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.07/string.mli000066400000000000000000000061261505130230400201550ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.07/stringLabels.mli000066400000000000000000000062441505130230400213010ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.07/sys.mli000066400000000000000000000041251505130230400174620ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.07/uchar.mli000066400000000000000000000005611505130230400177460ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.07/weak.mli000066400000000000000000000026151505130230400175750ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/000077500000000000000000000000001505130230400161405ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.08/arg.mli000066400000000000000000000030341505130230400174140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/array.mli000066400000000000000000000045121505130230400177630ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/arrayLabels.mli000066400000000000000000000047041505130230400211110ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/bool.mli000066400000000000000000000004671505130230400176050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/buffer.mli000066400000000000000000000027031505130230400201160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/bytes.mli000066400000000000000000000070031505130230400177710ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.08/bytesLabels.mli000066400000000000000000000072301505130230400211160ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.08/callback.mli000066400000000000000000000001231505130230400203730ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.08/char.mli000066400000000000000000000005221505130230400175570ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.08/complex.mli000066400000000000000000000006021505130230400203100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/digest.mli000066400000000000000000000006221505130230400201220ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/ephemeron.mli000066400000000000000000000315441505130230400206340ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.08/filename.mli000066400000000000000000000015131505130230400204230ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.08/float.mli000066400000000000000000000172271505130230400177610ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.08/format.mli000066400000000000000000000215401505130230400201350ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/fun.mli000066400000000000000000000003621505130230400174340ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.08/gc.mli000066400000000000000000000036211505130230400172360ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/genlex.mli000066400000000000000000000003011505130230400201170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/hashtbl.mli000066400000000000000000000125161505130230400202750ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.08/int32.mli000066400000000000000000000035631505130230400176110ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.08/int64.mli000066400000000000000000000041471505130230400176150ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.08/lazy.mli000066400000000000000000000004751505130230400176300ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/lexing.mli000066400000000000000000000031331505130230400201310ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/list.mli000066400000000000000000000051741505130230400176250ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/listLabels.mli000066400000000000000000000053561505130230400207520ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/map.mli000066400000000000000000000076301505130230400174260ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.08/marshal.mli000066400000000000000000000011031505130230400202650ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/moreLabels.mli000066400000000000000000000325441505130230400207400ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.08/nativeint.mli000066400000000000000000000041001505130230400206370ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.08/obj.mli000066400000000000000000000041701505130230400174170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/oo.mli000066400000000000000000000002571505130230400172640ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.08/option.mli000066400000000000000000000013331505130230400201530ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/parsing.mli000066400000000000000000000017421505130230400203120ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.08/pervasives.mli000066400000000000000000000240071505130230400210350ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.08/printexc.mli000066400000000000000000000026351505130230400205050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/printf.mli000066400000000000000000000013221505130230400201430ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.08/queue.mli000066400000000000000000000011151505130230400177650ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/random.mli000066400000000000000000000012701505130230400201230ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.08/result.mli000066400000000000000000000021341505130230400201610ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.08/scanf.mli000066400000000000000000000031641505130230400177410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.08/seq.mli000066400000000000000000000005761505130230400174430ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/set.mli000066400000000000000000000060321505130230400174370ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.08/spacetime.mli000066400000000000000000000005151505130230400206160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.08/stack.mli000066400000000000000000000007361505130230400177560ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/stdLabels.mli000066400000000000000000000001541505130230400205600ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.08/stdlib.mli000066400000000000000000000267641505130230400201430ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.08/stream.mli000066400000000000000000000013201505130230400201320ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.08/string.mli000066400000000000000000000042271505130230400201560ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.08/stringLabels.mli000066400000000000000000000043771505130230400213070ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.08/sys.mli000066400000000000000000000041651505130230400174670ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.08/uchar.mli000066400000000000000000000005611505130230400177470ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.08/unit.mli000066400000000000000000000001531505130230400176210ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.08/weak.mli000066400000000000000000000026151505130230400175760ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/000077500000000000000000000000001505130230400161415ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.09/arg.mli000066400000000000000000000030341505130230400174150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/array.mli000066400000000000000000000045121505130230400177640ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/arrayLabels.mli000066400000000000000000000047041505130230400211120ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/bool.mli000066400000000000000000000004671505130230400176060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/buffer.mli000066400000000000000000000027031505130230400201170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/bytes.mli000066400000000000000000000072651505130230400200040ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.09/bytesLabels.mli000066400000000000000000000074461505130230400211300ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.09/callback.mli000066400000000000000000000001231505130230400203740ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.09/char.mli000066400000000000000000000005221505130230400175600ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.09/complex.mli000066400000000000000000000006021505130230400203110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/digest.mli000066400000000000000000000006221505130230400201230ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/ephemeron.mli000066400000000000000000000315441505130230400206350ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.09/filename.mli000066400000000000000000000015131505130230400204240ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.09/float.mli000066400000000000000000000172271505130230400177620ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.09/format.mli000066400000000000000000000215401505130230400201360ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/fun.mli000066400000000000000000000003621505130230400174350ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.09/gc.mli000066400000000000000000000036211505130230400172370ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/genlex.mli000066400000000000000000000003011505130230400201200ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/hashtbl.mli000066400000000000000000000125161505130230400202760ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.09/int32.mli000066400000000000000000000035631505130230400176120ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.09/int64.mli000066400000000000000000000041471505130230400176160ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.09/lazy.mli000066400000000000000000000004751505130230400176310ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/lexing.mli000066400000000000000000000031331505130230400201320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/list.mli000066400000000000000000000051741505130230400176260ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/listLabels.mli000066400000000000000000000053561505130230400207530ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/map.mli000066400000000000000000000076301505130230400174270ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.09/marshal.mli000066400000000000000000000011031505130230400202660ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/moreLabels.mli000066400000000000000000000325441505130230400207410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.09/nativeint.mli000066400000000000000000000041001505130230400206400ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.09/obj.mli000066400000000000000000000042601505130230400174200ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/oo.mli000066400000000000000000000002571505130230400172650ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.09/option.mli000066400000000000000000000013331505130230400201540ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/parsing.mli000066400000000000000000000017421505130230400203130ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.09/pervasives.mli000066400000000000000000000240071505130230400210360ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.09/printexc.mli000066400000000000000000000027531505130230400205070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/printf.mli000066400000000000000000000013221505130230400201440ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.09/queue.mli000066400000000000000000000011151505130230400177660ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/random.mli000066400000000000000000000012701505130230400201240ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.09/result.mli000066400000000000000000000021341505130230400201620ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.09/scanf.mli000066400000000000000000000031641505130230400177420ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.09/seq.mli000066400000000000000000000005761505130230400174440ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/set.mli000066400000000000000000000060321505130230400174400ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.09/spacetime.mli000066400000000000000000000005151505130230400206170ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.09/stack.mli000066400000000000000000000007361505130230400177570ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/stdLabels.mli000066400000000000000000000001541505130230400205610ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.09/stdlib.mli000066400000000000000000000270071505130230400201330ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.09/stream.mli000066400000000000000000000013201505130230400201330ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.09/string.mli000066400000000000000000000042271505130230400201570ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.09/stringLabels.mli000066400000000000000000000043771505130230400213100ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.09/sys.mli000066400000000000000000000042101505130230400174570ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.09/uchar.mli000066400000000000000000000005611505130230400177500ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.09/unit.mli000066400000000000000000000001531505130230400176220ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.09/weak.mli000066400000000000000000000026151505130230400175770ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/000077500000000000000000000000001505130230400161315ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.10/arg.mli000066400000000000000000000030341505130230400174050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/array.mli000066400000000000000000000045121505130230400177540ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/arrayLabels.mli000066400000000000000000000047041505130230400211020ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/bool.mli000066400000000000000000000004671505130230400175760ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/buffer.mli000066400000000000000000000027031505130230400201070ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/bytes.mli000066400000000000000000000072651505130230400177740ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.10/bytesLabels.mli000066400000000000000000000074461505130230400211200ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.10/callback.mli000066400000000000000000000001231505130230400203640ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.10/char.mli000066400000000000000000000005221505130230400175500ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.10/complex.mli000066400000000000000000000006021505130230400203010ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/digest.mli000066400000000000000000000006221505130230400201130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/ephemeron.mli000066400000000000000000000315441505130230400206250ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.10/filename.mli000066400000000000000000000017221505130230400204160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.10/float.mli000066400000000000000000000172271505130230400177520ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.10/format.mli000066400000000000000000000215401505130230400201260ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/fun.mli000066400000000000000000000003621505130230400174250ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.10/gc.mli000066400000000000000000000036211505130230400172270ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/genlex.mli000066400000000000000000000003011505130230400201100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/hashtbl.mli000066400000000000000000000125161505130230400202660ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.10/int32.mli000066400000000000000000000035631505130230400176020ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.10/int64.mli000066400000000000000000000041471505130230400176060ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.10/lazy.mli000066400000000000000000000004751505130230400176210ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/lexing.mli000066400000000000000000000031331505130230400201220ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/list.mli000066400000000000000000000053541505130230400176160ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/listLabels.mli000066400000000000000000000055421505130230400207400ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/map.mli000066400000000000000000000076301505130230400174170ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.10/marshal.mli000066400000000000000000000011031505130230400202560ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/moreLabels.mli000066400000000000000000000325441505130230400207310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.10/nativeint.mli000066400000000000000000000041001505130230400206300ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.10/obj.mli000066400000000000000000000042601505130230400174100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/oo.mli000066400000000000000000000002571505130230400172550ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.10/option.mli000066400000000000000000000013331505130230400201440ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/parsing.mli000066400000000000000000000017421505130230400203030ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.10/pervasives.mli000066400000000000000000000240071505130230400210260ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.10/printexc.mli000066400000000000000000000030171505130230400204710ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/printf.mli000066400000000000000000000013221505130230400201340ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.10/queue.mli000066400000000000000000000011151505130230400177560ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/random.mli000066400000000000000000000012701505130230400201140ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.10/result.mli000066400000000000000000000021341505130230400201520ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.10/scanf.mli000066400000000000000000000031641505130230400177320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.10/seq.mli000066400000000000000000000005761505130230400174340ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/set.mli000066400000000000000000000060321505130230400174300ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.10/spacetime.mli000066400000000000000000000005151505130230400206070ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.10/stack.mli000066400000000000000000000007361505130230400177470ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/stdLabels.mli000066400000000000000000000001541505130230400205510ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.10/stdlib.mli000066400000000000000000000270071505130230400201230ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.10/stream.mli000066400000000000000000000013201505130230400201230ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.10/string.mli000066400000000000000000000042271505130230400201470ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.10/stringLabels.mli000066400000000000000000000043771505130230400213000ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.10/sys.mli000066400000000000000000000050551505130230400174570ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.10/uchar.mli000066400000000000000000000005611505130230400177400ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.10/unit.mli000066400000000000000000000001531505130230400176120ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.10/weak.mli000066400000000000000000000026151505130230400175670ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/000077500000000000000000000000001505130230400161325ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.11/arg.mli000066400000000000000000000030341505130230400174060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/array.mli000066400000000000000000000047151505130230400177620ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/arrayLabels.mli000066400000000000000000000051131505130230400210760ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/bool.mli000066400000000000000000000004671505130230400175770ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/buffer.mli000066400000000000000000000027031505130230400201100ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/bytes.mli000066400000000000000000000072651505130230400177750ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.11/bytesLabels.mli000066400000000000000000000074461505130230400211210ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.11/callback.mli000066400000000000000000000001231505130230400203650ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.11/char.mli000066400000000000000000000005221505130230400175510ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.11/complex.mli000066400000000000000000000006021505130230400203020ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/digest.mli000066400000000000000000000006221505130230400201140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/ephemeron.mli000066400000000000000000000315441505130230400206260ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.11/filename.mli000066400000000000000000000017221505130230400204170ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.11/float.mli000066400000000000000000000172271505130230400177530ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.11/format.mli000066400000000000000000000217321505130230400201320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/fun.mli000066400000000000000000000003621505130230400174260ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.11/gc.mli000066400000000000000000000051261505130230400172320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/genlex.mli000066400000000000000000000003011505130230400201110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/hashtbl.mli000066400000000000000000000125161505130230400202670ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.11/int32.mli000066400000000000000000000035631505130230400176030ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.11/int64.mli000066400000000000000000000041471505130230400176070ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.11/lazy.mli000066400000000000000000000004751505130230400176220ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/lexing.mli000066400000000000000000000032651505130230400201310ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/list.mli000066400000000000000000000055651505130230400176230ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/listLabels.mli000066400000000000000000000057641505130230400207470ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/map.mli000066400000000000000000000100241505130230400174070ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.11/marshal.mli000066400000000000000000000011031505130230400202570ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/moreLabels.mli000066400000000000000000000331261505130230400207270ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.11/nativeint.mli000066400000000000000000000041001505130230400206310ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.11/obj.mli000066400000000000000000000042601505130230400174110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/oo.mli000066400000000000000000000002571505130230400172560ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.11/option.mli000066400000000000000000000013331505130230400201450ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/parsing.mli000066400000000000000000000017421505130230400203040ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.11/pervasives.mli000066400000000000000000000240071505130230400210270ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.11/printexc.mli000066400000000000000000000031651505130230400204760ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/printf.mli000066400000000000000000000015501505130230400201400ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.11/queue.mli000066400000000000000000000011151505130230400177570ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/random.mli000066400000000000000000000012701505130230400201150ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.11/result.mli000066400000000000000000000021341505130230400201530ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.11/scanf.mli000066400000000000000000000031641505130230400177330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.11/seq.mli000066400000000000000000000007621505130230400174320ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/set.mli000066400000000000000000000062001505130230400174260ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.11/spacetime.mli000066400000000000000000000005151505130230400206100ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.11/stack.mli000066400000000000000000000007361505130230400177500ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/stdLabels.mli000066400000000000000000000001541505130230400205520ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.11/stdlib.mli000066400000000000000000000270071505130230400201240ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.11/stream.mli000066400000000000000000000013201505130230400201240ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.11/string.mli000066400000000000000000000042271505130230400201500ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.11/stringLabels.mli000066400000000000000000000043771505130230400213010ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.11/sys.mli000066400000000000000000000050551505130230400174600ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.11/uchar.mli000066400000000000000000000005611505130230400177410ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.11/unit.mli000066400000000000000000000001531505130230400176130ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.11/weak.mli000066400000000000000000000026151505130230400175700ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/000077500000000000000000000000001505130230400161335ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.12/arg.mli000066400000000000000000000031031505130230400174040ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/array.mli000066400000000000000000000047151505130230400177630ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/arrayLabels.mli000066400000000000000000000051131505130230400210770ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/atomic.mli000066400000000000000000000003741505130230400201160ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.12/bool.mli000066400000000000000000000004671505130230400176000ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/buffer.mli000066400000000000000000000027031505130230400201110ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/bytes.mli000066400000000000000000000072651505130230400177760ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.12/bytesLabels.mli000066400000000000000000000074461505130230400211220ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.12/callback.mli000066400000000000000000000001231505130230400203660ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.12/char.mli000066400000000000000000000005221505130230400175520ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.12/complex.mli000066400000000000000000000006021505130230400203030ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/digest.mli000066400000000000000000000006221505130230400201150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/either.mli000066400000000000000000000015641505130230400201240ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.12/ephemeron.mli000066400000000000000000000315551505130230400206310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.12/filename.mli000066400000000000000000000017221505130230400204200ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.12/float.mli000066400000000000000000000172271505130230400177540ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.12/format.mli000066400000000000000000000221251505130230400201300ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/fun.mli000066400000000000000000000003621505130230400174270ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.12/gc.mli000066400000000000000000000053051505130230400172320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/genlex.mli000066400000000000000000000003011505130230400201120ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/hashtbl.mli000066400000000000000000000126131505130230400202660ustar00rootroot00000000000000type (!'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 stdcompat-21.1/interfaces/4.12/int32.mli000066400000000000000000000035631505130230400176040ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.12/int64.mli000066400000000000000000000041471505130230400176100ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.12/lazy.mli000066400000000000000000000004751505130230400176230ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/lexing.mli000066400000000000000000000032651505130230400201320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/list.mli000066400000000000000000000061011505130230400176070ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/listLabels.mli000066400000000000000000000063111505130230400207350ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/map.mli000066400000000000000000000101621505130230400174130ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.12/marshal.mli000066400000000000000000000011031505130230400202600ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/moreLabels.mli000066400000000000000000000341211505130230400207240ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.12/nativeint.mli000066400000000000000000000041001505130230400206320ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.12/obj.mli000066400000000000000000000047201505130230400174130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/oo.mli000066400000000000000000000002571505130230400172570ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.12/option.mli000066400000000000000000000013331505130230400201460ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/parsing.mli000066400000000000000000000017421505130230400203050ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.12/pervasives.mli000066400000000000000000000240071505130230400210300ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.12/printexc.mli000066400000000000000000000034731505130230400205010ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/printf.mli000066400000000000000000000015501505130230400201410ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.12/queue.mli000066400000000000000000000011161505130230400177610ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.12/random.mli000066400000000000000000000012701505130230400201160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.12/result.mli000066400000000000000000000021341505130230400201540ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.12/scanf.mli000066400000000000000000000031641505130230400177340ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.12/seq.mli000066400000000000000000000007621505130230400174330ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.12/set.mli000066400000000000000000000063101505130230400174310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.12/stack.mli000066400000000000000000000007371505130230400177520ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.12/stdLabels.mli000066400000000000000000000001541505130230400205530ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.12/stdlib.mli000066400000000000000000000271111505130230400201210ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.12/stream.mli000066400000000000000000000013211505130230400201260ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.12/string.mli000066400000000000000000000042271505130230400201510ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/4.12/stringLabels.mli000066400000000000000000000043771505130230400213020ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/4.12/sys.mli000066400000000000000000000052321505130230400174560ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.12/uchar.mli000066400000000000000000000005611505130230400177420ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.12/unit.mli000066400000000000000000000001531505130230400176140ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.12/weak.mli000066400000000000000000000026161505130230400175720ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.13/000077500000000000000000000000001505130230400161345ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.13/arg.mli000066400000000000000000000031031505130230400174050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/array.mli000066400000000000000000000053721505130230400177640ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/arrayLabels.mli000066400000000000000000000056031505130230400211040ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/atomic.mli000066400000000000000000000003741505130230400201170ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.13/bool.mli000066400000000000000000000004671505130230400176010ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/buffer.mli000066400000000000000000000027031505130230400201120ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/bytes.mli000066400000000000000000000100171505130230400177640ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.13/bytesLabels.mli000066400000000000000000000102261505130230400211110ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.13/callback.mli000066400000000000000000000001231505130230400203670ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.13/char.mli000066400000000000000000000005221505130230400175530ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.13/complex.mli000066400000000000000000000006021505130230400203040ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/digest.mli000066400000000000000000000006221505130230400201160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/either.mli000066400000000000000000000015641505130230400201250ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.13/ephemeron.mli000066400000000000000000000315551505130230400206320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.13/filename.mli000066400000000000000000000017221505130230400204210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.13/float.mli000066400000000000000000000205351505130230400177510ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.13/format.mli000066400000000000000000000224551505130230400201370ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/fun.mli000066400000000000000000000003621505130230400174300ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.13/gc.mli000066400000000000000000000053051505130230400172330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/genlex.mli000066400000000000000000000003011505130230400201130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/hashtbl.mli000066400000000000000000000126131505130230400202670ustar00rootroot00000000000000type (!'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 stdcompat-21.1/interfaces/4.13/int32.mli000066400000000000000000000036371505130230400176070ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.13/int64.mli000066400000000000000000000042231505130230400176040ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.13/lazy.mli000066400000000000000000000006131505130230400176160ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/lexing.mli000066400000000000000000000032651505130230400201330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/list.mli000066400000000000000000000061011505130230400176100ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/listLabels.mli000066400000000000000000000063111505130230400207360ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/map.mli000066400000000000000000000101621505130230400174140ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.13/marshal.mli000066400000000000000000000011031505130230400202610ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/moreLabels.mli000066400000000000000000000341211505130230400207250ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.13/nativeint.mli000066400000000000000000000041541505130230400206440ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.13/obj.mli000066400000000000000000000047201505130230400174140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/oo.mli000066400000000000000000000002571505130230400172600ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.13/option.mli000066400000000000000000000013331505130230400201470ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/parsing.mli000066400000000000000000000017421505130230400203060ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.13/pervasives.mli000066400000000000000000000240071505130230400210310ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.13/printexc.mli000066400000000000000000000034731505130230400205020ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/printf.mli000066400000000000000000000015501505130230400201420ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.13/queue.mli000066400000000000000000000011161505130230400177620ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.13/random.mli000066400000000000000000000013631505130230400201220ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.13/result.mli000066400000000000000000000021341505130230400201550ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.13/scanf.mli000066400000000000000000000031641505130230400177350ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.13/seq.mli000066400000000000000000000010741505130230400174310ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.13/set.mli000066400000000000000000000063101505130230400174320ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.13/stack.mli000066400000000000000000000007371505130230400177530ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.13/stdLabels.mli000066400000000000000000000001541505130230400205540ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.13/stdlib.mli000066400000000000000000000275321505130230400201310ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.13/stream.mli000066400000000000000000000013211505130230400201270ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.13/string.mli000066400000000000000000000061671505130230400201570ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/4.13/stringLabels.mli000066400000000000000000000063611505130230400212760ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/4.13/sys.mli000066400000000000000000000052321505130230400174570ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.13/uchar.mli000066400000000000000000000005611505130230400177430ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.13/unit.mli000066400000000000000000000001531505130230400176150ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.13/weak.mli000066400000000000000000000026161505130230400175730ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.14/000077500000000000000000000000001505130230400161355ustar00rootroot00000000000000stdcompat-21.1/interfaces/4.14/arg.mli000066400000000000000000000031031505130230400174060ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/array.mli000066400000000000000000000053721505130230400177650ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/arrayLabels.mli000066400000000000000000000056031505130230400211050ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/atomic.mli000066400000000000000000000003741505130230400201200ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.14/bool.mli000066400000000000000000000004671505130230400176020ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/buffer.mli000066400000000000000000000027031505130230400201130ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/bytes.mli000066400000000000000000000106521505130230400177720ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.14/bytesLabels.mli000066400000000000000000000110611505130230400211100ustar00rootroot00000000000000external 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 ] stdcompat-21.1/interfaces/4.14/callback.mli000066400000000000000000000001231505130230400203700ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/4.14/char.mli000066400000000000000000000005221505130230400175540ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/4.14/complex.mli000066400000000000000000000006021505130230400203050ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/digest.mli000066400000000000000000000006221505130230400201170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/either.mli000066400000000000000000000015641505130230400201260ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.14/ephemeron.mli000066400000000000000000000340631505130230400206300ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.14/filename.mli000066400000000000000000000017221505130230400204220ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.14/float.mli000066400000000000000000000205351505130230400177520ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.14/format.mli000066400000000000000000000224551505130230400201400ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/fun.mli000066400000000000000000000003621505130230400174310ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.14/gc.mli000066400000000000000000000053051505130230400172340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/genlex.mli000066400000000000000000000003011505130230400201140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/hashtbl.mli000066400000000000000000000126131505130230400202700ustar00rootroot00000000000000type (!'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 stdcompat-21.1/interfaces/4.14/in_channel.mli000066400000000000000000000016461505130230400207450ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/int32.mli000066400000000000000000000036371505130230400176100ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.14/int64.mli000066400000000000000000000042231505130230400176050ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.14/lazy.mli000066400000000000000000000006131505130230400176170ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/lexing.mli000066400000000000000000000032651505130230400201340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/list.mli000066400000000000000000000061011505130230400176110ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/listLabels.mli000066400000000000000000000063111505130230400207370ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/map.mli000066400000000000000000000101621505130230400174150ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.14/marshal.mli000066400000000000000000000011031505130230400202620ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/moreLabels.mli000066400000000000000000000341211505130230400207260ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.14/nativeint.mli000066400000000000000000000041541505130230400206450ustar00rootroot00000000000000val 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" stdcompat-21.1/interfaces/4.14/obj.mli000066400000000000000000000046151505130230400174200ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/oo.mli000066400000000000000000000002571505130230400172610ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/4.14/option.mli000066400000000000000000000013331505130230400201500ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/out_channel.mli000066400000000000000000000020111505130230400211310ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/parsing.mli000066400000000000000000000017421505130230400203070ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.14/pervasives.mli000066400000000000000000000240071505130230400210320ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.14/printexc.mli000066400000000000000000000034731505130230400205030ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/printf.mli000066400000000000000000000015501505130230400201430ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.14/queue.mli000066400000000000000000000011161505130230400177630ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.14/random.mli000066400000000000000000000016561505130230400201300ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/4.14/result.mli000066400000000000000000000021341505130230400201560ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/4.14/scanf.mli000066400000000000000000000031641505130230400177360ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.14/seq.mli000066400000000000000000000046661505130230400174440ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/4.14/set.mli000066400000000000000000000063101505130230400174330ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/4.14/stack.mli000066400000000000000000000007371505130230400177540ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.14/stdLabels.mli000066400000000000000000000001541505130230400205550ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/4.14/stdlib.mli000066400000000000000000000276321505130230400201330ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.14/stream.mli000066400000000000000000000013211505130230400201300ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/4.14/string.mli000066400000000000000000000065711505130230400201570ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/4.14/stringLabels.mli000066400000000000000000000067631505130230400213050ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/4.14/sys.mli000066400000000000000000000056401505130230400174630ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/4.14/uchar.mli000066400000000000000000000012611505130230400177420ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/4.14/unit.mli000066400000000000000000000001531505130230400176160ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/4.14/weak.mli000066400000000000000000000026161505130230400175740ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.0/000077500000000000000000000000001505130230400160515ustar00rootroot00000000000000stdcompat-21.1/interfaces/5.0/arg.mli000066400000000000000000000031031505130230400173220ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/array.mli000066400000000000000000000051441505130230400176760ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/arrayLabels.mli000066400000000000000000000053431505130230400210220ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/atomic.mli000066400000000000000000000003741505130230400200340ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.0/bool.mli000066400000000000000000000004671505130230400175160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/buffer.mli000066400000000000000000000027031505130230400200270ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/bytes.mli000066400000000000000000000105151505130230400177040ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.0/bytesLabels.mli000066400000000000000000000107241505130230400210310ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.0/callback.mli000066400000000000000000000001231505130230400203040ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/5.0/char.mli000066400000000000000000000004301505130230400174660ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/5.0/complex.mli000066400000000000000000000006021505130230400202210ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/digest.mli000066400000000000000000000006221505130230400200330ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/domain.mli000066400000000000000000000007521505130230400200270ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.0/either.mli000066400000000000000000000015641505130230400200420ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/5.0/ephemeron.mli000066400000000000000000000177041505130230400205470ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.0/filename.mli000066400000000000000000000016671505130230400203460ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/float.mli000066400000000000000000000205351505130230400176660ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/format.mli000066400000000000000000000204171505130230400200500ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/fun.mli000066400000000000000000000003621505130230400173450ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.0/gc.mli000066400000000000000000000045701505130230400171530ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/hashtbl.mli000066400000000000000000000126221505130230400202040ustar00rootroot00000000000000type (!'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 stdcompat-21.1/interfaces/5.0/in_channel.mli000066400000000000000000000016461505130230400206610ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/int32.mli000066400000000000000000000035351505130230400175210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/int64.mli000066400000000000000000000041211505130230400175160ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/lazy.mli000066400000000000000000000004441505130230400175350ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/lexing.mli000066400000000000000000000032651505130230400200500ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/list.mli000066400000000000000000000061011505130230400175250ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/listLabels.mli000066400000000000000000000063111505130230400206530ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/map.mli000066400000000000000000000101621505130230400173310ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.0/marshal.mli000066400000000000000000000011031505130230400201760ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/moreLabels.mli000066400000000000000000000341341505130230400206460ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.0/nativeint.mli000066400000000000000000000040421505130230400205550ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/obj.mli000066400000000000000000000044441505130230400173340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/oo.mli000066400000000000000000000002571505130230400171750ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/5.0/option.mli000066400000000000000000000013331505130230400200640ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/out_channel.mli000066400000000000000000000020111505130230400210450ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/parsing.mli000066400000000000000000000017421505130230400202230ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/printexc.mli000066400000000000000000000035611505130230400204150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/printf.mli000066400000000000000000000015501505130230400200570ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/queue.mli000066400000000000000000000011161505130230400176770ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.0/random.mli000066400000000000000000000017371505130230400200440ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.0/result.mli000066400000000000000000000021341505130230400200720ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/5.0/scanf.mli000066400000000000000000000033331505130230400176500ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.0/seq.mli000066400000000000000000000046661505130230400173600ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.0/set.mli000066400000000000000000000063101505130230400173470ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.0/stack.mli000066400000000000000000000000011505130230400176500ustar00rootroot00000000000000 stdcompat-21.1/interfaces/5.0/stdLabels.mli000066400000000000000000000001541505130230400204710ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/5.0/stdlib.mli000066400000000000000000000276311505130230400200460ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.0/string.mli000066400000000000000000000056751505130230400200770ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/5.0/stringLabels.mli000066400000000000000000000057431505130230400212160ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/5.0/sys.mli000066400000000000000000000056401505130230400173770ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.0/uchar.mli000066400000000000000000000012611505130230400176560ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.0/unit.mli000066400000000000000000000001531505130230400175320ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/5.0/weak.mli000066400000000000000000000026161505130230400175100ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.1/000077500000000000000000000000001505130230400160525ustar00rootroot00000000000000stdcompat-21.1/interfaces/5.1/arg.mli000066400000000000000000000031031505130230400173230ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/array.mli000066400000000000000000000055401505130230400176770ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/arrayLabels.mli000066400000000000000000000057471505130230400210330ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/atomic.mli000066400000000000000000000003741505130230400200350ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.1/bool.mli000066400000000000000000000005631505130230400175140ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/buffer.mli000066400000000000000000000027031505130230400200300ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/bytes.mli000066400000000000000000000105351505130230400177070ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.1/bytesLabels.mli000066400000000000000000000107441505130230400210340ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.1/callback.mli000066400000000000000000000001231505130230400203050ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/5.1/char.mli000066400000000000000000000005161505130230400174740ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/5.1/complex.mli000066400000000000000000000006021505130230400202220ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/digest.mli000066400000000000000000000006221505130230400200340ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/domain.mli000066400000000000000000000007521505130230400200300ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.1/either.mli000066400000000000000000000015641505130230400200430ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/5.1/ephemeron.mli000066400000000000000000000177041505130230400205500ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.1/filename.mli000066400000000000000000000020031505130230400203300ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/float.mli000066400000000000000000000221731505130230400176670ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/format.mli000066400000000000000000000210501505130230400200430ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/fun.mli000066400000000000000000000003621505130230400173460ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.1/gc.mli000066400000000000000000000045701505130230400171540ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/hashtbl.mli000066400000000000000000000126721505130230400202120ustar00rootroot00000000000000type (!'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 stdcompat-21.1/interfaces/5.1/in_channel.mli000066400000000000000000000020371505130230400206550ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/int32.mli000066400000000000000000000036231505130230400175200ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/int64.mli000066400000000000000000000042071505130230400175240ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/lazy.mli000066400000000000000000000004441505130230400175360ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/lexing.mli000066400000000000000000000032651505130230400200510ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/list.mli000066400000000000000000000064041505130230400175340ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/listLabels.mli000066400000000000000000000066141505130230400206620ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/map.mli000066400000000000000000000106361505130230400173400ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.1/marshal.mli000066400000000000000000000011031505130230400201770ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/moreLabels.mli000066400000000000000000000351261505130230400206510ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.1/nativeint.mli000066400000000000000000000041301505130230400205540ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/obj.mli000066400000000000000000000042211505130230400173260ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/oo.mli000066400000000000000000000002571505130230400171760ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/5.1/option.mli000066400000000000000000000013331505130230400200650ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/out_channel.mli000066400000000000000000000020401505130230400210500ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/parsing.mli000066400000000000000000000017421505130230400202240ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/printexc.mli000066400000000000000000000035611505130230400204160ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/printf.mli000066400000000000000000000015501505130230400200600ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/queue.mli000066400000000000000000000011261505130230400177010ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.1/random.mli000066400000000000000000000020511505130230400200330ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.1/result.mli000066400000000000000000000021341505130230400200730ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/5.1/scanf.mli000066400000000000000000000033331505130230400176510ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.1/seq.mli000066400000000000000000000051001505130230400173410ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.1/set.mli000066400000000000000000000064301505130230400173530ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.1/stack.mli000066400000000000000000000007771505130230400176750ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.1/stdLabels.mli000066400000000000000000000001541505130230400204720ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/5.1/stdlib.mli000066400000000000000000000276541505130230400200540ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.1/string.mli000066400000000000000000000057151505130230400200730ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/5.1/stringLabels.mli000066400000000000000000000057631505130230400212210ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/5.1/sys.mli000066400000000000000000000057471505130230400174100ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.1/uchar.mli000066400000000000000000000012611505130230400176570ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.1/unit.mli000066400000000000000000000001531505130230400175330ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/5.1/weak.mli000066400000000000000000000026361505130230400175130ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.2/000077500000000000000000000000001505130230400160535ustar00rootroot00000000000000stdcompat-21.1/interfaces/5.2/arg.mli000066400000000000000000000031031505130230400173240ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/array.mli000066400000000000000000000057311505130230400177020ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/arrayLabels.mli000066400000000000000000000061561505130230400210270ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/atomic.mli000066400000000000000000000004341505130230400200330ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.2/bool.mli000066400000000000000000000005631505130230400175150ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/buffer.mli000066400000000000000000000027031505130230400200310ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/bytes.mli000066400000000000000000000105351505130230400177100ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.2/bytesLabels.mli000066400000000000000000000107441505130230400210350ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.2/callback.mli000066400000000000000000000001231505130230400203060ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-21.1/interfaces/5.2/char.mli000066400000000000000000000005161505130230400174750ustar00rootroot00000000000000external 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" stdcompat-21.1/interfaces/5.2/complex.mli000066400000000000000000000006021505130230400202230ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/digest.mli000066400000000000000000000017031505130230400200360ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/domain.mli000066400000000000000000000007521505130230400200310ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.2/either.mli000066400000000000000000000015641505130230400200440ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/5.2/ephemeron.mli000066400000000000000000000177041505130230400205510ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.2/filename.mli000066400000000000000000000020031505130230400203310ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/float.mli000066400000000000000000000227371505130230400176760ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/format.mli000066400000000000000000000211571505130230400200540ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/fun.mli000066400000000000000000000004451505130230400173510ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.2/gc.mli000066400000000000000000000046301505130230400171520ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/hashtbl.mli000066400000000000000000000126721505130230400202130ustar00rootroot00000000000000type (!'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 stdcompat-21.1/interfaces/5.2/in_channel.mli000066400000000000000000000025171505130230400206610ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/int32.mli000066400000000000000000000036231505130230400175210ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/int64.mli000066400000000000000000000042071505130230400175250ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/lazy.mli000066400000000000000000000004441505130230400175370ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/lexing.mli000066400000000000000000000032651505130230400200520ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/list.mli000066400000000000000000000064041505130230400175350ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/listLabels.mli000066400000000000000000000066141505130230400206630ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/map.mli000066400000000000000000000106361505130230400173410ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.2/marshal.mli000066400000000000000000000011031505130230400202000ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/moreLabels.mli000066400000000000000000000351261505130230400206520ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.2/nativeint.mli000066400000000000000000000041301505130230400205550ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/obj.mli000066400000000000000000000040531505130230400173320ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/oo.mli000066400000000000000000000002571505130230400171770ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-21.1/interfaces/5.2/option.mli000066400000000000000000000013331505130230400200660ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/out_channel.mli000066400000000000000000000023021505130230400210520ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/parsing.mli000066400000000000000000000017421505130230400202250ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/printexc.mli000066400000000000000000000036241505130230400204170ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/printf.mli000066400000000000000000000015501505130230400200610ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/queue.mli000066400000000000000000000011261505130230400177020ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.2/random.mli000066400000000000000000000027751505130230400200510ustar00rootroot00000000000000val 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 stdcompat-21.1/interfaces/5.2/result.mli000066400000000000000000000021341505130230400200740ustar00rootroot00000000000000type ('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 stdcompat-21.1/interfaces/5.2/scanf.mli000066400000000000000000000033331505130230400176520ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.2/seq.mli000066400000000000000000000051001505130230400173420ustar00rootroot00000000000000type '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 stdcompat-21.1/interfaces/5.2/set.mli000066400000000000000000000064301505130230400173540ustar00rootroot00000000000000module 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 stdcompat-21.1/interfaces/5.2/stack.mli000066400000000000000000000007771505130230400176760ustar00rootroot00000000000000type !'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 stdcompat-21.1/interfaces/5.2/stdLabels.mli000066400000000000000000000001541505130230400204730ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-21.1/interfaces/5.2/stdlib.mli000066400000000000000000000277071505130230400200540ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.2/string.mli000066400000000000000000000057151505130230400200740ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/5.2/stringLabels.mli000066400000000000000000000057631505130230400212220ustar00rootroot00000000000000type 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 ] stdcompat-21.1/interfaces/5.2/sys.mli000066400000000000000000000057471505130230400174110ustar00rootroot00000000000000external 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 stdcompat-21.1/interfaces/5.2/uchar.mli000066400000000000000000000012611505130230400176600ustar00rootroot00000000000000type 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 stdcompat-21.1/interfaces/5.2/unit.mli000066400000000000000000000001531505130230400175340ustar00rootroot00000000000000type t = unit = | () val equal : t -> t -> bool val compare : t -> t -> int val to_string : t -> string stdcompat-21.1/interfaces/5.2/weak.mli000066400000000000000000000026361505130230400175140ustar00rootroot00000000000000type !'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 stdcompat-21.1/missing000077500000000000000000000153361505130230400150330ustar00rootroot00000000000000#! /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: stdcompat-21.1/stdcompat.ml.in000066400000000000000000000001261505130230400163600ustar00rootroot00000000000000include Stdcompat__root module Stdlib = Stdcompat__stdlib include Stdcompat__stdlib stdcompat-21.1/stdcompat.mli.in000066400000000000000000000003561505130230400165360ustar00rootroot00000000000000type 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 stdcompat-21.1/stdcompat.opam000066400000000000000000000014571505130230400163070ustar00rootroot00000000000000opam-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: "Sébastien Hinderer " authors: "Thierry Martinez " license: "LGPL-2.1-or-later" homepage: "https://github.com/ocamllibs/stdcompat" bug-reports: "https://github.com/ocamllibs/stdcompat/issues" depends: [ "ocaml" {>= "4.11" & < "5.4"} "dune" {>= "2.0"} ] build: [ ["dune" "subst"] {dev} ["dune" "build" "-p" name "-j" jobs] ["dune" "runtest" "-p" name "-j" jobs] {with-test} ] dev-repo: "git+https://github.com/ocamllibs/stdcompat.git" version: "21.0" stdcompat-21.1/stdcompat__arg.ml.in000066400000000000000000000101521505130230400173500ustar00rootroot00000000000000@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/ocamllibs/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@ stdcompat-21.1/stdcompat__arg.mli.in000066400000000000000000000000331505130230400175160ustar00rootroot00000000000000include Stdcompat__arg_s.S stdcompat-21.1/stdcompat__arg_s.mli.in000066400000000000000000000107101505130230400200430ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__array.ml.in000066400000000000000000000125041505130230400177200ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__array.mli.in000066400000000000000000000000351505130230400200650ustar00rootroot00000000000000include Stdcompat__array_s.S stdcompat-21.1/stdcompat__arrayLabels.ml.in000066400000000000000000000004231505130230400210400ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__arrayLabels.mli.in000066400000000000000000000000431505130230400212070ustar00rootroot00000000000000include Stdcompat__arrayLabels_s.S stdcompat-21.1/stdcompat__arrayLabels_s.mli.in000066400000000000000000000206021505130230400215340ustar00rootroot00000000000000module 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@ @BEGIN_BEFORE_5_3_0@ external create_float : int -> float array = "caml_make_float_vect" @END_BEFORE_5_3_0@ @BEGIN_FROM_5_3_0@ external create_float: int -> float array = "caml_array_create_float" @END_FROM_5_3_0@ @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@ @BEGIN_BEFORE_5_3_0@ external make : int -> 'a -> 'a array = "caml_make_vect" @END_BEFORE_5_3_0@ @BEGIN_FROM_5_3_0@ external make : int -> 'a -> 'a array = "caml_array_make" @END_FROM_5_3_0@ @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 stdcompat-21.1/stdcompat__array_s.mli.in000066400000000000000000000177131505130230400204220ustar00rootroot00000000000000module 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@ @BEGIN_BEFORE_5_3_0@ external create_float : int -> float array = "caml_make_float_vect" @END_BEFORE_5_3_0@ @BEGIN_FROM_5_3_0@ external create_float: int -> float array = "caml_array_create_float" @END_FROM_5_3_0@ @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@ @BEGIN_BEFORE_5_3_0@ external make : int -> 'a -> 'a array = "caml_make_vect" @END_BEFORE_5_3_0@ @BEGIN_FROM_5_3_0@ external make : int -> 'a -> 'a array = "caml_array_make" @END_FROM_5_3_0@ @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 stdcompat-21.1/stdcompat__atomic.ml.in000066400000000000000000000010321505130230400200500ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__atomic.mli.in000066400000000000000000000000361505130230400202240ustar00rootroot00000000000000include Stdcompat__atomic_s.S stdcompat-21.1/stdcompat__atomic_s.mli.in000066400000000000000000000020071505130230400205460ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__bool.ml.in000066400000000000000000000010041505130230400175260ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__bool.mli.in000066400000000000000000000000341505130230400177010ustar00rootroot00000000000000include Stdcompat__bool_s.S stdcompat-21.1/stdcompat__bool_s.mli.in000066400000000000000000000035241505130230400202320ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__buffer.ml.in000066400000000000000000000125151505130230400200550ustar00rootroot00000000000000include 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 Sys.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 Sys.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 Sys.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@ stdcompat-21.1/stdcompat__buffer.mli.in000066400000000000000000000000361505130230400202210ustar00rootroot00000000000000include Stdcompat__buffer_s.S stdcompat-21.1/stdcompat__buffer_s.mli.in000066400000000000000000000120321505130230400205420ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__bytes.ml.in000066400000000000000000000563521505130230400177410ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__bytes.mli.in000066400000000000000000000000351505130230400200750ustar00rootroot00000000000000include Stdcompat__bytes_s.S stdcompat-21.1/stdcompat__bytesLabels.ml.in000066400000000000000000000000311505130230400210430ustar00rootroot00000000000000include Stdcompat__bytes stdcompat-21.1/stdcompat__bytesLabels.mli.in000066400000000000000000000000431505130230400212170ustar00rootroot00000000000000include Stdcompat__bytesLabels_s.S stdcompat-21.1/stdcompat__bytesLabels_s.mli.in000066400000000000000000000673701505130230400215610ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__bytes_s.mli.in000066400000000000000000000656721505130230400204410ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__char.ml.in000066400000000000000000000004321505130230400175140ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__char.mli.in000066400000000000000000000000341505130230400176630ustar00rootroot00000000000000include Stdcompat__char_s.S stdcompat-21.1/stdcompat__char_s.mli.in000066400000000000000000000014601505130230400202110ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__digest.ml.in000066400000000000000000000035371505130230400200670ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__digest.mli.in000066400000000000000000000000361505130230400202270ustar00rootroot00000000000000include Stdcompat__digest_s.S stdcompat-21.1/stdcompat__digest_s.mli.in000066400000000000000000000075711505130230400205640ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__domain.ml.in000066400000000000000000000024521505130230400200520ustar00rootroot00000000000000@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@ @BEGIN_BEFORE_5_3_0@ let self_index () = failwith "not implemented" @END_BEFORE_5_3_0@ stdcompat-21.1/stdcompat__domain.mli.in000066400000000000000000000000361505130230400202170ustar00rootroot00000000000000include Stdcompat__domain_s.S stdcompat-21.1/stdcompat__domain_s.mli.in000066400000000000000000000032321505130230400205420ustar00rootroot00000000000000module 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 *) val self_index : unit -> int (** @since 5.3: self_index : unit -> int *) end stdcompat-21.1/stdcompat__dynarray.ml.in000066400000000000000000001142721505130230400204400ustar00rootroot00000000000000@BEGIN_BEFORE_5_3_0@ (**************************************************************************) (* *) (* OCaml *) (* *) (* Gabriel Scherer, projet Partout, INRIA Paris-Saclay *) (* *) (* Copyright 2022 Institut National de Recherche en Informatique et *) (* en Automatique. *) (* *) (* All rights reserved. This file is distributed under the terms of *) (* the GNU Lesser General Public License version 2.1, with the *) (* special exception on linking described in the file LICENSE. *) (* *) (**************************************************************************) (* {2 The type ['a t]} A dynamic array is represented using a backing array [arr] and a [length]. It behaves as an array of size [length] -- the indices from [0] to [length - 1] included contain user-provided values and can be [get] and [set] -- but the length may also change in the future by adding or removing elements at the end. We use the following concepts; - capacity: the length of the backing array: [Array.length arr] - live space: the portion of the backing array with indices from [0] to [length - 1] included. - empty space: the portion of the backing array from [length] to the end of the backing array. {2 Dummies} We should not keep a user-provided value in the empty space, as this could extend its lifetime and may result in memory leaks of arbitrary size. Functions that remove elements from the dynamic array, such as [pop_last] or [truncate], must really erase the element from the backing array. To do so, we use an unsafe/magical [dummy] in the empty array. This dummy is *not* type-safe, it is not a valid value of type ['a], so we must be very careful never to return it to the user. After accessing any element of the array, we must check that it is not the dummy. In particular, this dummy must be distinct from any other value the user could provide -- we ensure this by using a dynamically-allocated mutable reference as our dummy. {2 Invariants and valid states} We enforce the invariant that [length >= 0] at all times. we rely on this invariant for optimization. The following conditions define what we call a "valid" dynarray: - valid length: [length <= Array.length arr] - no missing element in the live space: forall i, [0 <= i < length] implies [arr.(i) != dummy] - no element in the empty space: forall i, [length <= i < Array.length arr] implies [arr.(i) == dummy] Unfortunately, we cannot easily enforce validity as an invariant in presence of concurrent updates. We can thus observe dynarrays in "invalid states". Our implementation may raise exceptions or return incorrect results on observing invalid states, but of course it must preserve memory safety. {3 Dummies and flat float arrays} OCaml performs a dynamic optimization of the representation of float arrays, which is incompatible with our use of a dummy value: if we initialize an array with user-provided elements, it may get an optimized into a "flat float array", and writing our non-float dummy into it would crash. To avoid interactions between unsafe dummies and flat float arrays, we ensure that the arrays that we use are never initialized with floating point values. In that case we will always get a non-flat array, and storing float values inside those is safe (if less efficient). We call this the 'no-flat-float' invariant. {3 Marshalling dummies} There is a risk of interaction between dummies and marshalling. If we use a global dynamically-allocated dummy for the whole module, we are not robust to a user marshalling a dynarray and unmarshalling it inside another program with a different global dummy. The trick is to store the dummy that we use in the dynarray metadata record. Marshalling the dynarray will then preserve the physical equality between this dummy field and dummy elements in the array, as expected. This reasoning assumes that marshalling does not use the [No_sharing] flag. To ensure that users do not marshal dummies with [No_sharing], we use a recursive/cyclic dummy that would make such marshalling loop forever. (This is not nice, but better than segfaulting later for obscure reasons.) *) (** The [Dummy] module encapsulates the low-level magic we use for dummies, providing a strongly-typed API that: - makes it explicit where dummies are used - makes it hard to mistakenly mix data using distinct dummies, which would be unsound *) module Dummy : sig (** {4 Dummies} *) type 'stamp dummy (** The type of dummies is parametrized by a ['stamp] variable, so that two dummies with different stamps cannot be confused together. *) type fresh_dummy = Fresh : 'stamp dummy -> fresh_dummy val fresh : unit -> fresh_dummy (** The type of [fresh] enforces a fresh/unknown/opaque stamp for the returned dummy, distinct from all previous stamps. *) (** {4 Values or dummies} *) type ('a, 'stamp) with_dummy (** a value of type [('a, 'stamp) with_dummy] is either a proper value of type ['a] or a dummy with stamp ['stamp]. *) val of_val : 'a -> ('a, 'stamp) with_dummy val of_dummy : 'stamp dummy -> ('a, 'stamp) with_dummy val is_dummy : ('a, 'stamp) with_dummy -> 'stamp dummy -> bool val unsafe_get : ('a, 'stamp) with_dummy -> 'a (** [unsafe_get v] can only be called safely if [is_dummy v dummy] is [false]. We could instead provide [val find : ('a, 'stamp) with_dummy -> ('a, 'stamp dummy) result] but this would involve intermediary allocations. {[match find x with | None -> ... | Some v -> ...]} can instead be written {[if Dummy.is_dummy x then ... else let v = Dummy.unsafe_get x in ...]} *) (** {4 Arrays of values or dummies} *) module Array : sig val make : int -> 'a -> dummy:'stamp dummy -> ('a, 'stamp) with_dummy array val init : int -> (int -> 'a) -> dummy:'stamp dummy -> ('a, 'stamp) with_dummy array val copy : 'a array -> dummy:'stamp dummy -> ('a, 'stamp) with_dummy array val unsafe_nocopy : 'a array -> dummy:'stamp dummy -> ('a, 'stamp) with_dummy array (** [unsafe_nocopy] assumes that the input array was created locally and will not be used anymore (in the spirit of [Bytes.unsafe_to_string]), and avoids a copy of the input array when possible. *) val blit_array : 'a array -> int -> ('a, 'stamp) with_dummy array -> int -> len:int -> unit val blit : ('a, 'stamp1) with_dummy array -> 'stamp1 dummy -> int -> ('a, 'stamp2) with_dummy array -> 'stamp2 dummy -> int -> len:int -> unit val prefix : ('a, 'stamp) with_dummy array -> int -> ('a, 'stamp) with_dummy array val extend : ('a, 'stamp) with_dummy array -> length:int -> dummy:'stamp dummy -> new_capacity:int -> ('a, 'stamp) with_dummy array end end = struct (* We want to use a cyclic value so that No_sharing marshalling fails loudly, but we want also comparison of dynarrays to work as expected, and not loop forever. Our approach is to use an object value that contains a cycle. Objects are compared by their unique id, so comparison is not structural and will not loop on the cycle, but marshalled by content, so marshalling without sharing will fail on the cycle. (It is a bit tricky to build an object that does not contain functional values where marshalling fails, see [fresh ()] below for how we do it.) *) type 'stamp dummy = < > type fresh_dummy = Fresh : 'stamp dummy -> fresh_dummy let fresh () = (* dummies and marshalling: we intentionally use a cyclic value here. *) let r = ref None in ignore (* hack: this primitive is required by the object expression below, ensure that 'make depend' notices it. *) CamlinternalOO.create_object_opt; let dummy = object val x = r end in r := Some dummy; Fresh dummy type ('a, 'stamp) with_dummy = 'a let of_val v = v let of_dummy (type a stamp) (dummy : stamp dummy) = (Obj.magic dummy : (a, stamp) with_dummy) let is_dummy v dummy = v == of_dummy dummy let unsafe_get v = v module Array = struct let make n x ~dummy = if Obj.(tag (repr x) <> double_tag) then Array.make n (of_val x) else begin let arr = Array.make n (of_dummy dummy) in Array.fill arr 0 n (of_val x); arr end let copy a ~dummy = if Obj.(tag (repr a) <> double_array_tag) then Array.copy a else begin let n = Array.length a in let arr = Array.make n (of_dummy dummy) in for i = 0 to n - 1 do Array.unsafe_set arr i (of_val (Array.unsafe_get a i)); done; arr end let unsafe_nocopy a ~dummy = if Obj.(tag (repr a) <> double_array_tag) then a else copy a ~dummy let init n f ~dummy = let arr = Array.make n (of_dummy dummy) in for i = 0 to n - 1 do Array.unsafe_set arr i (of_val (f i)) done; arr let blit_array src src_pos dst dst_pos ~len = if Obj.(tag (repr src) <> double_array_tag) then Array.blit src src_pos dst dst_pos len else begin for i = 0 to len - 1 do dst.(dst_pos + i) <- of_val src.(src_pos + i) done; end let blit src src_dummy src_pos dst dst_dummy dst_pos ~len = if src_dummy == dst_dummy then Array.blit src src_pos dst dst_pos len else begin if len < 0 || src_pos < 0 || src_pos + len < 0 (* overflow check *) || src_pos + len > Array.length src || dst_pos < 0 || dst_pos + len < 0 (* overflow check *) || dst_pos + len > Array.length dst then begin (* We assume that the caller has already checked this and will raise a proper error. The check here is only for memory safety, it should not be reached and it is okay if the error is uninformative. *) assert false; end; (* We failed the check [src_dummy == dst_dummy] above, so we know that in fact [src != dst] -- two dynarrays with distinct dummies cannot share the same backing arrays. *) assert (src != dst); (* In particular, the source and destination arrays cannot overlap, so we can always copy in ascending order without risking overwriting an element needed later. *) for i = 0 to len - 1 do Array.unsafe_set dst (dst_pos + i) (Array.unsafe_get src (src_pos + i)); done end let prefix arr n = (* Note: the safety of the [Array.sub] call below, with respect to our 'no-flat-float' invariant, relies on the fact that [Array.sub] checks the tag of the input array, not whether the elements themselves are float. To avoid relying on this undocumented property we could use [Array.make length dummy] and then set values in a loop, but this would result in [caml_modify] rather than [caml_initialize]. *) Array.sub arr 0 n let extend arr ~length ~dummy ~new_capacity = (* 'no-flat-float' invariant: we initialise the array with our non-float dummy to get a non-flat array. *) let new_arr = Array.make new_capacity (of_dummy dummy) in Array.blit arr 0 new_arr 0 length; new_arr end end type 'a t = Pack : ('a, 'stamp) t_ -> 'a t [@@unboxed] and ('a, 'stamp) t_ = { mutable length : int; mutable arr : ('a, 'stamp) Dummy.with_dummy array; dummy : 'stamp Dummy.dummy; } let global_dummy = Dummy.fresh () (* We need to ensure that dummies are never exposed to the user as values of type ['a]. Including the dummy in the dynarray metadata is necessary for marshalling to behave correctly, but there is no obligation to create a fresh dummy for each new dynarray, we can use a global dummy. On the other hand, unmarshalling may precisely return a dynarray with another dummy: we cannot assume that all dynarrays use this global dummy. The existential hiding of the dummy ['stamp] parameter helps us to avoid this assumption. *) module Error = struct let[@inline never] index_out_of_bounds f ~i ~length = if length = 0 then Printf.ksprintf invalid_arg "Dynarray.%s: index %d out of bounds (empty dynarray)" f i else Printf.ksprintf invalid_arg "Dynarray.%s: index %d out of bounds (0..%d)" f i (length - 1) let[@inline never] negative_length_requested f n = Printf.ksprintf invalid_arg "Dynarray.%s: negative length %d requested" f n let[@inline never] negative_capacity_requested f n = Printf.ksprintf invalid_arg "Dynarray.%s: negative capacity %d requested" f n let[@inline never] requested_length_out_of_bounds f requested_length = Printf.ksprintf invalid_arg "Dynarray.%s: cannot grow to requested length %d (max_array_length is %d)" f requested_length Sys.max_array_length (* When observing an invalid state ([missing_element], [invalid_length]), we do not give the name of the calling function in the error message, as the error is related to invalid operations performed earlier, and not to the callsite of the function itself. *) let invalid_state_description = "Invalid dynarray (unsynchronized concurrent length change)" let[@inline never] missing_element ~i ~length = Printf.ksprintf invalid_arg "%s: missing element at position %d < length %d" invalid_state_description i length let[@inline never] invalid_length ~length ~capacity = Printf.ksprintf invalid_arg "%s: length %d > capacity %d" invalid_state_description length capacity let[@inline never] length_change_during_iteration f ~expected ~observed = Printf.ksprintf invalid_arg "Dynarray.%s: a length change from %d to %d occurred during iteration" f expected observed (* When an [Empty] element is observed unexpectedly at index [i], it may be either an out-of-bounds access or an invalid-state situation depending on whether [i <= length]. *) let[@inline never] unexpected_empty_element f ~i ~length = if i < length then missing_element ~i ~length else index_out_of_bounds f ~i ~length let[@inline never] empty_dynarray f = Printf.ksprintf invalid_arg "Dynarray.%s: empty array" f end (* Detecting iterator invalidation. See {!iter} below for a detailed usage example. *) let check_same_length f (Pack a) ~length = let length_a = a.length in if length <> length_a then Error.length_change_during_iteration f ~expected:length ~observed:length_a (** Careful unsafe access. *) (* Postcondition on non-exceptional return: [length <= Array.length arr] *) let[@inline always] check_valid_length length arr = let capacity = Array.length arr in if length > capacity then Error.invalid_length ~length ~capacity (* Precondition: [0 <= i < length <= Array.length arr] This precondition is typically guaranteed by knowing [0 <= i < length] and calling [check_valid_length length arr].*) let[@inline always] unsafe_get arr ~dummy ~i ~length = let v = Array.unsafe_get arr i in if Dummy.is_dummy v dummy then Error.missing_element ~i ~length else Dummy.unsafe_get v (** {1:dynarrays Dynamic arrays} *) let create () = let Dummy.Fresh dummy = global_dummy in Pack { length = 0; arr = [| |]; dummy = dummy; } let make n x = if n < 0 then Error.negative_length_requested "make" n; let Dummy.Fresh dummy = global_dummy in let arr = Dummy.Array.make n x ~dummy in Pack { length = n; arr; dummy; } let init (type a) n (f : int -> a) : a t = if n < 0 then Error.negative_length_requested "init" n; let Dummy.Fresh dummy = global_dummy in let arr = Dummy.Array.init n f ~dummy in Pack { length = n; arr; dummy; } let get (type a) (Pack a : a t) i = (* This implementation will propagate an [Invalid_argument] exception from array lookup if the index is out of the backing array, instead of using our own [Error.index_out_of_bounds]. This is allowed by our specification, and more efficient -- no need to check that [length a <= capacity a] in the fast path. *) let v = a.arr.(i) in if Dummy.is_dummy v a.dummy then Error.unexpected_empty_element "get" ~i ~length:a.length else Dummy.unsafe_get v let set (Pack a) i x = let {arr; length; _} = a in if i >= length then Error.index_out_of_bounds "set" ~i ~length else arr.(i) <- Dummy.of_val x let length (Pack a) = a.length let is_empty (Pack a) = (a.length = 0) let copy (type a) (Pack {length; arr; dummy} : a t) : a t = check_valid_length length arr; (* use [length] as the new capacity to make this an O(length) operation. *) let arr = Dummy.Array.prefix arr length in Pack { length; arr; dummy } let get_last (Pack a) = let {arr; length; dummy} = a in check_valid_length length arr; (* We know [length <= capacity a]. *) if length = 0 then Error.empty_dynarray "get_last"; (* We know [length > 0]. *) unsafe_get arr ~dummy ~i:(length - 1) ~length let find_last (Pack a) = let {arr; length; dummy} = a in check_valid_length length arr; (* We know [length <= capacity a]. *) if length = 0 then None else (* We know [length > 0]. *) Some (unsafe_get arr ~dummy ~i:(length - 1) ~length) (** {1:removing Removing elements} *) let pop_last (Pack a) = let {arr; length; dummy} = a in check_valid_length length arr; (* We know [length <= capacity a]. *) if length = 0 then raise Not_found; let last = length - 1 in (* We know [length > 0] so [last >= 0]. *) let v = unsafe_get arr ~dummy ~i:last ~length in Array.unsafe_set arr last (Dummy.of_dummy dummy); a.length <- last; v let pop_last_opt a = match pop_last a with | exception Not_found -> None | x -> Some x let remove_last (Pack a) = let last = a.length - 1 in if last >= 0 then begin a.length <- last; a.arr.(last) <- Dummy.of_dummy a.dummy; end let truncate (Pack a) n = if n < 0 then Error.negative_length_requested "truncate" n; let {arr; length; dummy} = a in if length <= n then () else begin a.length <- n; Array.fill arr n (length - n) (Dummy.of_dummy dummy) end let clear a = truncate a 0 (** {1:capacity Backing array and capacity} *) let capacity (Pack a) = Array.length a.arr let next_capacity n = let n' = (* For large values of n, we use 1.5 as our growth factor. For smaller values of n, we grow more aggressively to avoid reallocating too much when accumulating elements into an empty array. The constants "512 words" and "8 words" below are taken from https://github.com/facebook/folly/blob/ c06c0f41d91daf1a6a5f3fc1cd465302ac260459/folly/FBVector.h#L1128-L1157 *) if n <= 512 then n * 2 else n + n / 2 in (* jump directly from 0 to 8 *) min (max 8 n') Sys.max_array_length let ensure_capacity (Pack a) capacity_request = let arr = a.arr in let cur_capacity = Array.length arr in if capacity_request < 0 then Error.negative_capacity_requested "ensure_capacity" capacity_request else if cur_capacity >= capacity_request then (* This is the fast path, the code up to here must do as little as possible. (This is why we don't use [let {arr; length} = a] as usual, the length is not needed in the fast path.)*) () else begin if capacity_request > Sys.max_array_length then Error.requested_length_out_of_bounds "ensure_capacity" capacity_request; let new_capacity = (* We use either the next exponential-growth strategy, or the requested strategy, whichever is bigger. Compared to only using the exponential-growth strategy, this lets us use less memory by avoiding any overshoot whenever the capacity request is noticeably larger than the current capacity. Compared to only using the requested capacity, this avoids losing the amortized guarantee: we allocated "exponentially or more", so the amortization holds. In particular, notice that repeated calls to [ensure_capacity a (length a + 1)] will have amortized-linear rather than quadratic complexity. *) max (next_capacity cur_capacity) capacity_request in assert (new_capacity > 0); let new_arr = Dummy.Array.extend arr ~length:a.length ~dummy:a.dummy ~new_capacity in a.arr <- new_arr; (* postcondition: *) assert (0 <= capacity_request); assert (capacity_request <= Array.length new_arr); end let ensure_extra_capacity a extra_capacity_request = ensure_capacity a (length a + extra_capacity_request) let fit_capacity (Pack a) = if Array.length a.arr = a.length then () else a.arr <- Dummy.Array.prefix a.arr a.length let set_capacity (Pack a) n = if n < 0 then Error.negative_capacity_requested "set_capacity" n; let arr = a.arr in let cur_capacity = Array.length arr in if n < cur_capacity then begin a.length <- min a.length n; a.arr <- Dummy.Array.prefix arr n; end else if n > cur_capacity then begin a.arr <- Dummy.Array.extend arr ~length:a.length ~dummy:a.dummy ~new_capacity:n; end let reset (Pack a) = a.length <- 0; a.arr <- [||] (** {1:adding Adding elements} *) (* We chose an implementation of [add_last a x] that behaves correctly in presence of asynchronous / re-entrant code execution around allocations and poll points: if another thread or a callback gets executed on allocation, we add the element at the new end of the dynamic array. (We do not give the same guarantees in presence of concurrent parallel updates, which are much more expensive to protect against.) *) (* [add_last_if_room a v] only writes the value if there is room, and returns [false] otherwise. *) let[@inline] add_last_if_room (Pack a) v = let {arr; length; _} = a in (* we know [0 <= length] *) if length >= Array.length arr then false else begin (* we know [0 <= length < Array.length arr] *) a.length <- length + 1; Array.unsafe_set arr length (Dummy.of_val v); true end let add_last a x = if add_last_if_room a x then () else begin (* slow path *) let rec grow_and_add a x = ensure_extra_capacity a 1; if not (add_last_if_room a x) then grow_and_add a x in grow_and_add a x end let rec append_list a li = match li with | [] -> () | x :: xs -> add_last a x; append_list a xs let append_iter a iter b = iter (fun x -> add_last a x) b let append_seq a seq = Seq.iter (fun x -> add_last a x) seq (* blitting *) let blit_assume_room (Pack src) src_pos src_length (Pack dst) dst_pos dst_length blit_length = (* The caller of [blit_assume_room] typically calls [ensure_capacity] right before. This could run asynchronous code. We want to fail reliably on any asynchronous length change, as it may invalidate the source and target ranges provided by the user. So we double-check that the lengths have not changed. *) let src_arr = src.arr in let dst_arr = dst.arr in check_same_length "blit" (Pack src) ~length:src_length; check_same_length "blit" (Pack dst) ~length:dst_length; if dst_pos + blit_length > dst_length then begin dst.length <- dst_pos + blit_length; end; (* note: [src] and [dst] may be equal when self-blitting, so [src.length] may have been mutated here. *) Dummy.Array.blit src_arr src.dummy src_pos dst_arr dst.dummy dst_pos ~len:blit_length let blit ~src ~src_pos ~dst ~dst_pos ~len = let src_length = length src in let dst_length = length dst in if len < 0 then Printf.ksprintf invalid_arg "Dynarray.blit: invalid blit length (%d)" len; if src_pos < 0 || src_pos + len > src_length then Printf.ksprintf invalid_arg "Dynarray.blit: invalid source region (%d..%d) \ in source dynarray of length %d" src_pos (src_pos + len) src_length; if dst_pos < 0 || dst_pos > dst_length then Printf.ksprintf invalid_arg "Dynarray.blit: invalid target region (%d..%d) \ in target dynarray of length %d" dst_pos (dst_pos + len) dst_length; ensure_capacity dst (dst_pos + len); blit_assume_room src src_pos src_length dst dst_pos dst_length len (* append_array: same [..._if_room] and loop logic as [add_last]. *) let append_array_if_room (Pack a) b = let {arr; length = length_a; _} = a in let length_b = Array.length b in if length_a + length_b > Array.length arr then false else begin (* Note: we intentionally update the length *before* filling the elements. This "reserve before fill" approach provides better behavior than "fill then notify" in presence of reentrant modifications (which may occur on [blit] below): - If some code asynchronously adds new elements after this length update, they will go after the space we just reserved, and in particular no addition will be lost. If instead we updated the length after the loop, any asynchronous addition during the loop could be erased or erase one of our additions, silently, without warning the user. - If some code asynchronously iterates on the dynarray, or removes elements, or otherwise tries to access the reserved-but-not-yet-filled space, it will get a clean "missing element" error. This is worse than with the fill-then-notify approach where the new elements would only become visible (to iterators, for removal, etc.) altogether at the end of loop. To summarise, "reserve before fill" is better on add-add races, and "fill then notify" is better on add-remove or add-iterate races. But the key difference is the failure mode: reserve-before fails on add-remove or add-iterate races with a clean error, while notify-after fails on add-add races with silently disappearing data. *) a.length <- length_a + length_b; Dummy.Array.blit_array b 0 arr length_a ~len:length_b; true end let append_array a b = if append_array_if_room a b then () else begin (* slow path *) let rec grow_and_append a b = ensure_extra_capacity a (Array.length b); if not (append_array_if_room a b) then grow_and_append a b in grow_and_append a b end (* append: same [..._if_room] and loop logic as [add_last]. *) (* It is a programming error to mutate the length of [b] during a call to [append a b]. To detect this mistake we keep track of the length of [b] throughout the computation and check it that does not change. *) let append_if_room (Pack a) b ~length_b = let {arr = arr_a; length = length_a; _} = a in if length_a + length_b > Array.length arr_a then false else begin (* blit [0..length_b-1] into [length_a..length_a+length_b-1]. *) blit_assume_room b 0 length_b (Pack a) length_a length_a length_b; check_same_length "append" b ~length:length_b; true end let append a b = let length_b = length b in if append_if_room a b ~length_b then () else begin (* slow path *) let rec grow_and_append a b ~length_b = ensure_extra_capacity a length_b; (* Eliding the [check_same_length] call below would be wrong in the case where [a] and [b] are aliases of each other, we would get into an infinite loop instead of failing. We could push the call to [append_if_room] itself, but we prefer to keep it in the slow path. *) check_same_length "append" b ~length:length_b; if not (append_if_room a b ~length_b) then grow_and_append a b ~length_b in grow_and_append a b ~length_b end (** {1:iteration Iteration} *) (* The implementation choice that we made for iterators is the one that maximizes efficiency by avoiding repeated bound checking: we check the length of the dynamic array once at the beginning, and then only operate on that portion of the dynarray, ignoring elements added in the meantime. The specification states that it is a programming error to mutate the length of the array during iteration. We check for this and raise an error on size change. Note that we may still miss some transient state changes that cancel each other and leave the length unchanged at the next check. *) let iter_ f k a = let Pack {arr; length; dummy} = a in (* [check_valid_length length arr] is used for memory safety, it guarantees that the backing array has capacity at least [length], allowing unsafe array access. [check_same_length] is used for correctness, it lets the function fail more often if we discover the programming error of mutating the length during iteration. We could, naively, call [check_same_length] at each iteration of the loop (before or after, or both). However, notice that this is not necessary to detect the removal of elements from [a]: if elements have been removed by the time the [for] loop reaches them, then [unsafe_get] will itself fail with an [Invalid_argument] exception. We only need to detect the addition of new elements to [a] during iteration, and for this it is enough to call [check_same_length] once at the end. Calling [check_same_length] more often could catch more programming errors, but the only errors that we miss with this optimization are those that keep the array size constant -- additions and deletions that cancel each other. We consider this an acceptable tradeoff. *) check_valid_length length arr; for i = 0 to length - 1 do k (unsafe_get arr ~dummy ~i ~length); done; check_same_length f a ~length let iter k a = iter_ "iter" k a let iteri k a = let Pack {arr; length; dummy} = a in check_valid_length length arr; for i = 0 to length - 1 do k i (unsafe_get arr ~dummy ~i ~length); done; check_same_length "iteri" a ~length let map f a = let Pack {arr = arr_in; length; dummy} = a in check_valid_length length arr_in; let arr_out = Array.make length (Dummy.of_dummy dummy) in for i = 0 to length - 1 do Array.unsafe_set arr_out i (Dummy.of_val (f (unsafe_get arr_in ~dummy ~i ~length))) done; let res = Pack { length; arr = arr_out; dummy; } in check_same_length "map" a ~length; res let mapi f a = let Pack {arr = arr_in; length; dummy} = a in check_valid_length length arr_in; let arr_out = Array.make length (Dummy.of_dummy dummy) in for i = 0 to length - 1 do Array.unsafe_set arr_out i (Dummy.of_val (f i (unsafe_get arr_in ~dummy ~i ~length))) done; let res = Pack { length; arr = arr_out; dummy; } in check_same_length "mapi" a ~length; res let fold_left f acc a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let r = ref acc in for i = 0 to length - 1 do let v = unsafe_get arr ~dummy ~i ~length in r := f !r v; done; check_same_length "fold_left" a ~length; !r let fold_right f a acc = let Pack {arr; length; dummy} = a in check_valid_length length arr; let r = ref acc in for i = length - 1 downto 0 do let v = unsafe_get arr ~dummy ~i ~length in r := f v !r; done; check_same_length "fold_right" a ~length; !r let exists p a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop p arr dummy i length = if i = length then false else p (unsafe_get arr ~dummy ~i ~length) || loop p arr dummy (i + 1) length in let res = loop p arr dummy 0 length in check_same_length "exists" a ~length; res let for_all p a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop p arr dummy i length = if i = length then true else p (unsafe_get arr ~dummy ~i ~length) && loop p arr dummy (i + 1) length in let res = loop p arr dummy 0 length in check_same_length "for_all" a ~length; res let filter f a = let b = create () in iter_ "filter" (fun x -> if f x then add_last b x) a; b let filter_map f a = let b = create () in iter_ "filter_map" (fun x -> match f x with | None -> () | Some y -> add_last b y ) a; b let mem x a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop i = if i = length then false else if Stdlib.compare (unsafe_get arr ~dummy ~i ~length) x = 0 then true else loop (succ i) in let res = loop 0 in check_same_length "mem" a ~length; res let memq x a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop i = if i = length then false else if (unsafe_get arr ~dummy ~i ~length) == x then true else loop (succ i) in let res = loop 0 in check_same_length "memq" a ~length; res let find_opt p a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop i = if i = length then None else let x = unsafe_get arr ~dummy ~i ~length in if p x then Some x else loop (succ i) in let res = loop 0 in check_same_length "find_opt" a ~length; res let find_index p a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop i = if i = length then None else let x = unsafe_get arr ~dummy ~i ~length in if p x then Some i else loop (succ i) in let res = loop 0 in check_same_length "find_index" a ~length; res let find_map p a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop i = if i = length then None else match p (unsafe_get arr ~dummy ~i ~length) with | None -> loop (succ i) | Some _ as r -> r in let res = loop 0 in check_same_length "find_map" a ~length; res let find_mapi p a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec loop i = if i = length then None else match p i (unsafe_get arr ~dummy ~i ~length) with | None -> loop (succ i) | Some _ as r -> r in let res = loop 0 in check_same_length "find_mapi" a ~length; res let equal eq a1 a2 = let Pack {arr = arr1; length = length; dummy = dum1} = a1 in let Pack {arr = arr2; length = len2; dummy = dum2} = a2 in if length <> len2 then false else begin check_valid_length length arr1; check_valid_length length arr2; let rec loop i = if i = length then true else eq (unsafe_get arr1 ~dummy:dum1 ~i ~length) (unsafe_get arr2 ~dummy:dum2 ~i ~length) && loop (i + 1) in let r = loop 0 in check_same_length "equal" a1 ~length; check_same_length "equal" a2 ~length; r end let compare cmp a1 a2 = let Pack {arr = arr1; length = length; dummy = dum1} = a1 in let Pack {arr = arr2; length = len2; dummy = dum2} = a2 in if length <> len2 then length - len2 else begin check_valid_length length arr1; check_valid_length length arr2; let rec loop i = if i = length then 0 else let c = cmp (unsafe_get arr1 ~dummy:dum1 ~i ~length) (unsafe_get arr2 ~dummy:dum2 ~i ~length) in if c <> 0 then c else loop (i + 1) in let r = loop 0 in check_same_length "compare" a1 ~length; check_same_length "compare" a2 ~length; r end (** {1:conversions Conversions to other data structures} *) (* The eager [to_*] conversion functions behave similarly to iterators in presence of updates during computation. The [*_reentrant] functions obey their more permissive specification, which tolerates any concurrent update. *) let of_array a = let length = Array.length a in let Dummy.Fresh dummy = global_dummy in let arr = Dummy.Array.copy a ~dummy in Pack { length; arr; dummy; } let to_array a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let res = Array.init length (fun i -> unsafe_get arr ~dummy ~i ~length ) in check_same_length "to_array" a ~length; res let of_list li = let a = Array.of_list li in let length = Array.length a in let Dummy.Fresh dummy = global_dummy in let arr = Dummy.Array.unsafe_nocopy a ~dummy in Pack { length; arr; dummy; } let to_list a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let l = ref [] in for i = length - 1 downto 0 do l := unsafe_get arr ~dummy ~i ~length :: !l done; check_same_length "to_list" a ~length; !l let of_seq seq = let init = create() in append_seq init seq; init let to_seq a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec aux i = fun () -> check_same_length "to_seq" a ~length; if i >= length then Seq.Nil else begin let v = unsafe_get arr ~dummy ~i ~length in Seq.Cons (v, aux (i + 1)) end in aux 0 let to_seq_reentrant a = let rec aux i = fun () -> if i >= length a then Seq.Nil else begin let v = get a i in Seq.Cons (v, aux (i + 1)) end in aux 0 let to_seq_rev a = let Pack {arr; length; dummy} = a in check_valid_length length arr; let rec aux i = fun () -> check_same_length "to_seq_rev" a ~length; if i < 0 then Seq.Nil else begin let v = unsafe_get arr ~dummy ~i ~length in Seq.Cons (v, aux (i - 1)) end in aux (length - 1) let to_seq_rev_reentrant a = let rec aux i = fun () -> if i < 0 then Seq.Nil else if i >= length a then (* If some elements have been removed in the meantime, we skip those elements and continue with the new end of the array. *) aux (length a - 1) () else begin let v = get a i in Seq.Cons (v, aux (i - 1)) end in aux (length a - 1) @END_BEFORE_5_3_0@ @BEGIN_FROM_5_3_0@ include Dynarray @END_FROM_5_3_0@ stdcompat-21.1/stdcompat__dynarray.mli.in000066400000000000000000000000401505130230400205740ustar00rootroot00000000000000include Stdcompat__dynarray_s.S stdcompat-21.1/stdcompat__dynarray_s.mli.in000066400000000000000000000044601505130230400211300ustar00rootroot00000000000000module type S = sig @BEGIN_BEFORE_4_12_0@ type 'a t @END_BEFORE_4_12_0@ @BEGIN_FROM_4_12_0@ type !'a t @END_FROM_4_12_0@ val create : unit -> 'a t val make : int -> 'a -> 'a t val init : int -> (int -> 'a) -> 'a t val get : 'a t -> int -> 'a val set : 'a t -> int -> 'a -> unit val length : 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int val is_empty : 'a t -> bool val get_last : 'a t -> 'a val find_last : 'a t -> 'a option val copy : 'a t -> 'a t val add_last : 'a t -> 'a -> unit val append_array : 'a t -> 'a array -> unit val append_list : 'a t -> 'a list -> unit val append : 'a t -> 'a t -> unit val append_seq : 'a t -> 'a Seq.t -> unit val append_iter : 'a t -> (('a -> unit) -> 'x -> unit) -> 'x -> unit val blit : src:'a t -> src_pos:int -> dst:'a t -> dst_pos:int -> len:int -> unit val pop_last_opt : 'a t -> 'a option val pop_last : 'a t -> 'a val remove_last : 'a t -> unit val truncate : 'a t -> int -> unit val clear : 'a t -> unit val iter : ('a -> unit) -> 'a t -> unit val iteri : (int -> 'a -> unit) -> 'a t -> unit val map : ('a -> 'b) -> 'a t -> 'b t val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a t -> 'acc val fold_right : ('a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc val mem : 'a -> 'a t -> bool val memq : 'a -> 'a t -> bool val exists : ('a -> bool) -> 'a t -> bool val for_all : ('a -> bool) -> 'a t -> bool val find_opt : ('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 filter : ('a -> bool) -> 'a t -> 'a t val filter_map : ('a -> 'b option) -> 'a t -> 'b t val of_array : 'a array -> 'a t val to_array : 'a t -> 'a array val of_list : 'a list -> 'a t val to_list : 'a t -> 'a list val of_seq : 'a Seq.t -> 'a t val to_seq : 'a t -> 'a Seq.t val to_seq_reentrant : 'a t -> 'a Seq.t val to_seq_rev : 'a t -> 'a Seq.t val to_seq_rev_reentrant : 'a t -> 'a Seq.t val capacity : 'a t -> int val ensure_capacity : 'a t -> int -> unit val ensure_extra_capacity : 'a t -> int -> unit val fit_capacity : 'a t -> unit val set_capacity : 'a t -> int -> unit val reset : 'a t -> unit end stdcompat-21.1/stdcompat__either.ml.in000066400000000000000000000023531505130230400200630ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__either.mli.in000066400000000000000000000000361505130230400202300ustar00rootroot00000000000000include Stdcompat__either_s.S stdcompat-21.1/stdcompat__either_s.mli.in000066400000000000000000000045711505130230400205620ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__ephemeron.ml.in000066400000000000000000000125401505130230400205640ustar00rootroot00000000000000@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/ocamllibs/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@ stdcompat-21.1/stdcompat__ephemeron.mli.in000066400000000000000000000000411505130230400207260ustar00rootroot00000000000000include Stdcompat__ephemeron_s.S stdcompat-21.1/stdcompat__ephemeron_s.mli.in000066400000000000000000000264511505130230400212650ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__filename.ml.in000066400000000000000000000152041505130230400203620ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__filename.mli.in000066400000000000000000000000401505130230400205230ustar00rootroot00000000000000include Stdcompat__filename_s.S stdcompat-21.1/stdcompat__filename_s.mli.in000066400000000000000000000046251505130230400210620ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__float.ml.in000066400000000000000000000554701505130230400177200ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__float.mli.in000066400000000000000000000000351505130230400200540ustar00rootroot00000000000000include Stdcompat__float_s.S stdcompat-21.1/stdcompat__float_s.mli.in000066400000000000000000000740051505130230400204060ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__format.ml.in000066400000000000000000000200251505130230400200670ustar00rootroot00000000000000@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@ @BEGIN_BEFORE_5_3_0@ let pp_print_substring_as ~pos ~len _state _size _s = let _pos = pos in let _len = len in failwith "Not implemented." let pp_print_substring ~pos ~len state s = pp_print_substring_as ~pos ~len state len s let print_substring ~pos ~len _v = let _pos = pos in let _len = len in failwith "Not implemented." (* pp_print_substring ~pos ~len (DLS.get std_formatter_key) v *) let print_substring_as ~pos ~len _as_len _v = let _pos = pos in let _len = len in failwith "Not implemented." (* pp_print_substring_as ~pos ~len (DLS.get std_formatter_key) as_len v *) @END_BEFORE_5_3_0@ stdcompat-21.1/stdcompat__format.mli.in000066400000000000000000000000361505130230400202400ustar00rootroot00000000000000include Stdcompat__format_s.S stdcompat-21.1/stdcompat__format_s.mli.in000066400000000000000000000664571505130230400206050ustar00rootroot00000000000000module 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 pp_print_substring : pos:int -> len:int -> formatter -> string -> unit val print_substring : pos:int -> len:int -> string -> unit val pp_print_substring_as : pos:int -> len:int -> formatter -> int -> string -> unit val print_substring_as : pos:int -> len:int -> int -> string -> unit 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 stdcompat-21.1/stdcompat__fun.ml.in000066400000000000000000000016201505130230400173670ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__fun.mli.in000066400000000000000000000000331505130230400175350ustar00rootroot00000000000000include Stdcompat__fun_s.S stdcompat-21.1/stdcompat__fun_s.mli.in000066400000000000000000000013621505130230400200650ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__hashtbl.ml.in000066400000000000000000000245771505130230400202440ustar00rootroot00000000000000type 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@ stdcompat-21.1/stdcompat__hashtbl.mli.in000066400000000000000000000000371505130230400203760ustar00rootroot00000000000000include Stdcompat__hashtbl_s.S stdcompat-21.1/stdcompat__hashtbl_ext.ml.in000066400000000000000000000124001505130230400211020ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__hashtbl_ext.mli.in000066400000000000000000000063201505130230400212570ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__hashtbl_s.mli.in000066400000000000000000000437231505130230400207310ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__in_channel.ml.in000066400000000000000000000101401505130230400206720ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__in_channel.mli.in000066400000000000000000000000421505130230400210430ustar00rootroot00000000000000include Stdcompat__in_channel_s.S stdcompat-21.1/stdcompat__in_channel_s.mli.in000066400000000000000000000100371505130230400213720ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__init.mli.in000066400000000000000000000026021505130230400177140ustar00rootroot00000000000000@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 = ('a, 'b) Stdlib.result = | 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_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@ stdcompat-21.1/stdcompat__int.ml.in000066400000000000000000000020241505130230400173700ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__int.mli.in000066400000000000000000000000331505130230400175370ustar00rootroot00000000000000include Stdcompat__int_s.S stdcompat-21.1/stdcompat__int32.ml.in000066400000000000000000000053621505130230400175450ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__int32.mli.in000066400000000000000000000000351505130230400177060ustar00rootroot00000000000000include Stdcompat__int32_s.S stdcompat-21.1/stdcompat__int32_s.mli.in000066400000000000000000000133661505130230400202430ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__int64.ml.in000066400000000000000000000022671505130230400175530ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__int64.mli.in000066400000000000000000000000351505130230400177130ustar00rootroot00000000000000include Stdcompat__int64_s.S stdcompat-21.1/stdcompat__int64_s.mli.in000066400000000000000000000145321505130230400202440ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__int_s.mli.in000066400000000000000000000020471505130230400200700ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__lazy.ml.in000066400000000000000000000004571505130230400175650ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__lazy.mli.in000066400000000000000000000000341505130230400177250ustar00rootroot00000000000000include Stdcompat__lazy_s.S stdcompat-21.1/stdcompat__lazy_s.mli.in000066400000000000000000000020361505130230400202530ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__lexing.ml.in000066400000000000000000000016121505130230400200660ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__lexing.mli.in000066400000000000000000000000361505130230400202360ustar00rootroot00000000000000include Stdcompat__lexing_s.S stdcompat-21.1/stdcompat__lexing_s.mli.in000066400000000000000000000106551505130230400205700ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__list.ml.in000066400000000000000000000116771505130230400175670ustar00rootroot00000000000000include 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@ @BEGIN_BEFORE_5_3_0@ let take n l = let[@tail_mod_cons] rec aux n l = match n, l with | 0, _ | _, [] -> [] | n, x::l -> x::aux (n - 1) l in if n < 0 then invalid_arg "List.take"; aux n l let drop n l = let rec aux i = function | _x::l when i < n -> aux (i + 1) l | rest -> rest in if n < 0 then invalid_arg "List.drop"; aux 0 l let take_while p l = let[@tail_mod_cons] rec aux = function | x::l when p x -> x::aux l | _rest -> [] in aux l let rec drop_while p = function | x::l when p x -> drop_while p l | rest -> rest @END_BEFORE_5_3_0@ stdcompat-21.1/stdcompat__list.mli.in000066400000000000000000000000341505130230400177210ustar00rootroot00000000000000include Stdcompat__list_s.S stdcompat-21.1/stdcompat__listLabels.ml.in000066400000000000000000000000301505130230400206670ustar00rootroot00000000000000include Stdcompat__list stdcompat-21.1/stdcompat__listLabels.mli.in000066400000000000000000000000421505130230400210430ustar00rootroot00000000000000include Stdcompat__listLabels_s.S stdcompat-21.1/stdcompat__listLabels_s.mli.in000066400000000000000000000230061505130230400213720ustar00rootroot00000000000000module 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} *) val take : int -> 'a list -> 'a list val drop : int -> 'a list -> 'a list val take_while : f:('a -> bool) -> 'a list -> 'a list val drop_while : f:('a -> bool) -> 'a list -> 'a list end stdcompat-21.1/stdcompat__list_s.mli.in000066400000000000000000000217551505130230400202600ustar00rootroot00000000000000module 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} *) val take : int -> 'a list -> 'a list val drop : int -> 'a list -> 'a list val take_while : ('a -> bool) -> 'a list -> 'a list val drop_while : ('a -> bool) -> 'a list -> 'a list end stdcompat-21.1/stdcompat__map.ml.in000066400000000000000000000605641505130230400173700ustar00rootroot00000000000000module 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@ stdcompat-21.1/stdcompat__map.mli.in000066400000000000000000000000331505130230400175220ustar00rootroot00000000000000include Stdcompat__map_s.S stdcompat-21.1/stdcompat__map_s.mli.in000066400000000000000000000217251505130230400200570ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__moreLabels.ml.in000066400000000000000000000006361505130230400206720ustar00rootroot00000000000000@BEGIN_FROM_5_0_0@ module Hashtbl = MoreLabels.Hashtbl @END_FROM_5_0_0@ @BEGIN_BEFORE_5_0_0@ module Hashtbl = Stdcompat__hashtbl @END_BEFORE_5_0_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@ stdcompat-21.1/stdcompat__moreLabels.mli.in000066400000000000000000000000421505130230400210320ustar00rootroot00000000000000include Stdcompat__moreLabels_s.S stdcompat-21.1/stdcompat__moreLabels_s.mli.in000066400000000000000000000340361505130230400213660ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__native.ml_byte000066400000000000000000000000231505130230400204770ustar00rootroot00000000000000let native = false stdcompat-21.1/stdcompat__native.ml_native000066400000000000000000000000221505130230400210210ustar00rootroot00000000000000let native = true stdcompat-21.1/stdcompat__native.mli000066400000000000000000000000221505130230400176240ustar00rootroot00000000000000val native : bool stdcompat-21.1/stdcompat__nativeint.ml.in000066400000000000000000000022731505130230400206050ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__nativeint.mli.in000066400000000000000000000000411505130230400207450ustar00rootroot00000000000000include Stdcompat__nativeint_s.S stdcompat-21.1/stdcompat__nativeint_s.mli.in000066400000000000000000000124371505130230400213030ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__option.ml.in000066400000000000000000000024711505130230400201140ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__option.mli.in000066400000000000000000000000361505130230400202600ustar00rootroot00000000000000include Stdcompat__option_s.S stdcompat-21.1/stdcompat__option_s.mli.in000066400000000000000000000044441505130230400206110ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__out_channel.ml.in000066400000000000000000000033101505130230400210740ustar00rootroot00000000000000@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/ocamllibs/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@ stdcompat-21.1/stdcompat__out_channel.mli.in000066400000000000000000000000431505130230400212450ustar00rootroot00000000000000include Stdcompat__out_channel_s.S stdcompat-21.1/stdcompat__out_channel_s.mli.in000066400000000000000000000073731505130230400216040ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__pervasives.ml.in000066400000000000000000000041271505130230400207730ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__pervasives.mli.in000066400000000000000000000000421505130230400211340ustar00rootroot00000000000000include Stdcompat__pervasives_s.S stdcompat-21.1/stdcompat__pervasives_s.mli.in000066400000000000000000001034131505130230400214640ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__printexc.ml.in000066400000000000000000000114511505130230400204360ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__printexc.mli.in000066400000000000000000000000401505130230400205770ustar00rootroot00000000000000include Stdcompat__printexc_s.S stdcompat-21.1/stdcompat__printexc_s.mli.in000066400000000000000000000137531505130230400211400ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__printf.ml.in000066400000000000000000000010041505130230400200750ustar00rootroot00000000000000@BEGIN_BEFORE_4_11_0@ let not_implemented _ = failwith "Stdcompat.Printf is not implemented yet. Please fill an issue: https://github.com/ocamllibs/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 stdcompat-21.1/stdcompat__printf.mli.in000066400000000000000000000000361505130230400202520ustar00rootroot00000000000000include Stdcompat__printf_s.S stdcompat-21.1/stdcompat__printf_s.mli.in000066400000000000000000000101551505130230400205770ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__queue.ml.in000066400000000000000000000032361505130230400177300ustar00rootroot00000000000000include 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@ @BEGIN_BEFORE_5_3_0@ let drop q = ignore (take q) @END_BEFORE_5_3_0@ stdcompat-21.1/stdcompat__queue.mli.in000066400000000000000000000000351505130230400200730ustar00rootroot00000000000000include Stdcompat__queue_s.S stdcompat-21.1/stdcompat__queue_s.mli.in000066400000000000000000000044751505130230400204310ustar00rootroot00000000000000module 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} *) val drop : 'a t -> unit end stdcompat-21.1/stdcompat__random.ml.in000066400000000000000000000063041505130230400200630ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__random.mli.in000066400000000000000000000000361505130230400202300ustar00rootroot00000000000000include Stdcompat__random_s.S stdcompat-21.1/stdcompat__random_s.mli.in000066400000000000000000000051521505130230400205560ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__result.ml.in000066400000000000000000000032741505130230400201240ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__result.mli.in000066400000000000000000000000361505130230400202660ustar00rootroot00000000000000include Stdcompat__result_s.S stdcompat-21.1/stdcompat__result_s.mli.in000066400000000000000000000141071505130230400206140ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__root.ml.in000066400000000000000000000001211505130230400175550ustar00rootroot00000000000000type bytes = Stdcompat__init.bytes type floatarray = Stdcompat__init.floatarray stdcompat-21.1/stdcompat__root.mli.in000066400000000000000000000002501505130230400177310ustar00rootroot00000000000000type bytes = Stdcompat__init.bytes (** @before 4.02.0 alias to [string]. *) type floatarray = Stdcompat__init.floatarray (** @before 4.06.0 alias to [float array]. *) stdcompat-21.1/stdcompat__seq.ml.in000066400000000000000000000217011505130230400173710ustar00rootroot00000000000000@BEGIN_FROM_4_07_0@ include Seq @END_FROM_4_07_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@ stdcompat-21.1/stdcompat__seq.mli.in000066400000000000000000000000331505130230400175350ustar00rootroot00000000000000include Stdcompat__seq_s.S stdcompat-21.1/stdcompat__seq_s.mli.in000066400000000000000000000177201505130230400200720ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__set.ml.in000066400000000000000000000365731505130230400174110ustar00rootroot00000000000000module 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@ stdcompat-21.1/stdcompat__set.mli.in000066400000000000000000000000331505130230400175400ustar00rootroot00000000000000include Stdcompat__set_s.S stdcompat-21.1/stdcompat__set_s.mli.in000066400000000000000000000150141505130230400200670ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__stack.ml.in000066400000000000000000000026331505130230400177110ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__stack.mli.in000066400000000000000000000000351505130230400200540ustar00rootroot00000000000000include Stdcompat__stack_s.S stdcompat-21.1/stdcompat__stack_s.mli.in000066400000000000000000000063031505130230400204020ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__stdlib.ml.in000066400000000000000000000054631505130230400200710ustar00rootroot00000000000000@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 Domain = Stdcompat__domain module Dynarray = Stdcompat__dynarray 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@ stdcompat-21.1/stdcompat__stdlib.mli.in000066400000000000000000000000361505130230400202310ustar00rootroot00000000000000include Stdcompat__stdlib_s.S stdcompat-21.1/stdcompat__stdlib_s.mli.in000066400000000000000000000066641505130230400205700ustar00rootroot00000000000000module 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 Domain : Stdcompat__domain_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 stdcompat-21.1/stdcompat__string.ml.in000066400000000000000000000101351505130230400201060ustar00rootroot00000000000000include 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@ stdcompat-21.1/stdcompat__string.mli.in000066400000000000000000000000361505130230400202560ustar00rootroot00000000000000include Stdcompat__string_s.S stdcompat-21.1/stdcompat__stringLabels.ml.in000066400000000000000000000000321505130230400212240ustar00rootroot00000000000000include Stdcompat__string stdcompat-21.1/stdcompat__stringLabels.mli.in000066400000000000000000000000441505130230400214000ustar00rootroot00000000000000include Stdcompat__stringLabels_s.S stdcompat-21.1/stdcompat__stringLabels_s.mli.in000066400000000000000000000241111505130230400217230ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__string_s.mli.in000066400000000000000000000227771505130230400206200ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__stubs.c.in000066400000000000000000000046421505130230400175600ustar00rootroot00000000000000#include @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@ stdcompat-21.1/stdcompat__sys.ml.in000066400000000000000000000051051505130230400174170ustar00rootroot00000000000000include 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 = Sys.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@ @BEGIN_BEFORE_5_3_0@ let poll_actions () = failwith "not implemented" @END_BEFORE_5_3_0@ stdcompat-21.1/stdcompat__sys.mli.in000066400000000000000000000000331505130230400175630ustar00rootroot00000000000000include Stdcompat__sys_s.S stdcompat-21.1/stdcompat__sys_s.mli.in000066400000000000000000000265671505130230400201310ustar00rootroot00000000000000module 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} *) @BEGIN_FROM_5_3_0@ external poll_actions : unit -> unit = "%poll" @END_FROM_5_3_0@ @BEGIN_BEFORE_5_3_0@ val poll_actions : unit -> unit @END_BEFORE_5_3_0@ end stdcompat-21.1/stdcompat__tools.ml.in000066400000000000000000000021361505130230400177420ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__tools.mli.in000066400000000000000000000011401505130230400201050ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__uchar.ml.in000066400000000000000000000021251505130230400177020ustar00rootroot00000000000000@BEGIN_FROM_4_03_0@ include Uchar @END_FROM_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@ @BEGIN_BEFORE_5_3_0@ external seeded_hash_param : int -> int -> int -> 'a -> int = "caml_hash" [@@noalloc] let seeded_hash seed x = seeded_hash_param 10 100 seed x @END_BEFORE_5_3_0@ stdcompat-21.1/stdcompat__uchar.mli.in000066400000000000000000000000351505130230400200510ustar00rootroot00000000000000include Stdcompat__uchar_s.S stdcompat-21.1/stdcompat__uchar_s.mli.in000066400000000000000000000051251505130230400204000ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_14_0@ @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_FROM_4_14_0@ @BEGIN_BEFORE_4_14_0@ @BEGIN_FROM_4_03_0@ type t = Uchar.t @END_FROM_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 seeded_hash : int -> t -> int val hash : t -> int (** @since 4.03.0: val hash : t -> int *) end stdcompat-21.1/stdcompat__unit.ml.in000066400000000000000000000002701505130230400175560ustar00rootroot00000000000000@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@ stdcompat-21.1/stdcompat__unit.mli.in000066400000000000000000000000341505130230400177250ustar00rootroot00000000000000include Stdcompat__unit_s.S stdcompat-21.1/stdcompat__unit_s.mli.in000066400000000000000000000007061505130230400202550ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat__weak.ml.in000066400000000000000000000017241505130230400175330ustar00rootroot00000000000000type '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@ stdcompat-21.1/stdcompat__weak.mli.in000066400000000000000000000000341505130230400176750ustar00rootroot00000000000000include Stdcompat__weak_s.S stdcompat-21.1/stdcompat__weak_s.mli.in000066400000000000000000000101351505130230400202220ustar00rootroot00000000000000module 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 stdcompat-21.1/stdcompat_tests.ml.in000066400000000000000000001622431505130230400176130ustar00rootroot00000000000000let 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_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 stdcompat-21.1/tools/000077500000000000000000000000001505130230400145645ustar00rootroot00000000000000stdcompat-21.1/tools/Makefile000066400000000000000000000037241505130230400162320ustar00rootroot00000000000000OCAMLFIND := 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 $@ stdcompat-21.1/tools/compiler_version.ml000066400000000000000000000114601505130230400204770ustar00rootroot00000000000000(* Dealing with compiler versions *) type extra_prefix = Plus | Tilde let string_of_prefix = function | Plus -> "+" | Tilde -> "~" type extra_info = extra_prefix * string let string_of_extra_info (p, s) = (string_of_prefix p) ^ s let string_of_extra_info_opt = function | None -> "" | Some ei -> string_of_extra_info ei let ocaml_of_prefix = function | Plus -> "Plus" | Tilde -> "Tilde" let ocaml_of_extra_info (p, s) = Printf.sprintf "(%s, \"%s\")" (ocaml_of_prefix p) s let ocaml_of_extra_info_opt = function | None -> "None" | Some ei -> Printf.sprintf "Some %s" (ocaml_of_extra_info ei) type t = { major : int; minor : int; patch_level : int; extra_info : extra_info option; } let major v = v.major let minor v = v.minor let patch_level v= v.patch_level let extra_info v = v.extra_info let mk x y z = { major = x; minor = y; patch_level = z; extra_info = None; } (* Known compiler versions *) let v3_08_0 = mk 3 8 0 let v3_09_0 = mk 3 9 0 let v3_10_0 = mk 3 10 0 let v3_11_0 = mk 3 11 0 let v3_12_0 = mk 3 12 0 let v3_12_1 = mk 3 12 1 let v4_00_0 = mk 4 0 0 let v4_00_1 = mk 4 0 1 let v4_01_0 = mk 4 1 0 let v4_02_0 = mk 4 2 0 let v4_02_1 = mk 4 2 1 let v4_02_2 = mk 4 2 2 let v4_02_3 = mk 4 2 3 let v4_03_0 = mk 4 3 0 let v4_04_0 = mk 4 4 0 let v4_05_0 = mk 4 5 0 let v4_06_0 = mk 4 6 0 let v4_06_1 = mk 4 6 1 let v4_07_0 = mk 4 7 0 let v4_07_1 = mk 4 7 1 let v4_08_0 = mk 4 8 0 let v4_08_1 = mk 4 8 1 let v4_09_0 = mk 4 9 0 let v4_09_1 = mk 4 9 1 let v4_10_0 = mk 4 10 0 let v4_10_1 = mk 4 10 1 let v4_10_2 = mk 4 10 2 let v4_11_0 = mk 4 11 0 let v4_11_1 = mk 4 11 1 let v4_11_2 = mk 4 11 2 let v4_12_0 = mk 4 12 0 let v4_12_1 = mk 4 12 1 let v4_13_0 = mk 4 13 0 let v4_13_1 = mk 4 13 1 let v4_14_0 = mk 4 14 0 let v4_14_1 = mk 4 14 1 let v4_14_2 = mk 4 14 2 let v5_0_0 = mk 5 0 0 let v5_1_0 = mk 5 1 0 let v5_1_1 = mk 5 1 1 let v5_2_0 = mk 5 2 0 let v5_2_1 = mk 5 2 1 let v5_3_0 = mk 5 3 0 let known_versions = [ v3_08_0; v3_09_0; v3_10_0; v3_11_0; v3_12_0; v3_12_1; v4_00_0; v4_00_1; v4_01_0; v4_02_0; v4_02_1; v4_02_2; v4_02_3; v4_03_0; v4_04_0; v4_05_0; v4_06_0; v4_06_1; v4_07_0; v4_07_1; v4_08_0; v4_08_1; v4_09_0; v4_09_1; v4_10_0; v4_10_1; v4_10_2; v4_11_0; v4_11_1; v4_11_2; v4_12_0; v4_12_1; v4_13_0; v4_13_1; v4_14_0; v4_14_1; v4_14_2; v5_0_0; v5_1_0; v5_1_1; v5_2_0; v5_2_1; v5_3_0; ] let is_known v = List.mem v known_versions let is_development _ = false let make x y z extra_info = let v = mk x y z in if is_known v then { v with extra_info } else raise Not_found let to_string { major; minor; patch_level; extra_info } = let printer = Printf.sprintf in let printer = if major>=5 then printer "%d.%d.%d" else printer "%d.%02d.%d" in (printer major minor patch_level) ^ (string_of_extra_info_opt extra_info) let of_string version_string = let f major minor patch_level s = let extra_info_opt = if s="" then None else begin let prefix = match s.[0] with | '+' -> Plus | '~' -> Tilde | _ -> Printf.sprintf "The string '%s' is not a valid OCaml compiler version" s |> failwith in let l = String.length s in let extra = String.sub s 1 (l-1) in Some (prefix, extra) end in make major minor patch_level extra_info_opt in Scanf.sscanf version_string "%d.%d.%d%s" f let compare v1 v2 = if v1.major < v2.major then -1 else if v1.major = v2.major then begin if v1.minor < v2.minor then -1 else if v1.minor = v2.minor then begin if v1.patch_level < v2.patch_level then -1 else if v1.patch_level = v2.patch_level then 0 else 1 end else 1 end else 1 let for_all_pairs pred l = let rec for_all_pairs' = function | [] -> true | x::xs -> let pred' = pred x in (List.for_all pred' xs) && (for_all_pairs' xs) in for_all_pairs' l let test_reflexivity () = let cmp_is_refl v = (compare v v) = 0 in let compare_is_reflexive = List.for_all cmp_is_refl known_versions in let tmp = if compare_is_reflexive then "" else "NOT " in Printf.eprintf "The comparison of compiler versions is %sreflexive\n%!" tmp let test_ordering () = let is_smaller v1 v2 = (compare v1 v2) < 0 in let sorted = for_all_pairs is_smaller known_versions in let tmp = if sorted then "" else "NOT " in Printf.eprintf "The list of known compiler versions is %ssorted\n%!" tmp let test_antisymetry () = let pred v1 v2 = let n1 = compare v1 v2 in let n2 = compare v2 v1 in (n1<0 && n2>0) || (n1>0 && n2<0) in let tmp = if for_all_pairs pred known_versions then "" else "NOT " in Printf.eprintf "The ordering of versions is %santisymetric\n%!" tmp let test () = test_reflexivity (); test_ordering (); test_antisymetry () stdcompat-21.1/tools/compiler_version.mli000066400000000000000000000023531505130230400206510ustar00rootroot00000000000000(* Dealing with compiler versions *) type extra_prefix = Plus | Tilde type extra_info = extra_prefix * string type t (* Known compiler versions *) val v3_08_0 : t val v3_09_0 : t val v3_10_0 : t val v3_11_0 : t val v3_12_0 : t val v3_12_1 : t val v4_00_0 : t val v4_00_1 : t val v4_01_0 : t val v4_02_0 : t val v4_02_1 : t val v4_02_2 : t val v4_02_3 : t val v4_03_0 : t val v4_04_0 : t val v4_05_0 : t val v4_06_0 : t val v4_06_1 : t val v4_07_0 : t val v4_07_1 : t val v4_08_0 : t val v4_08_1 : t val v4_09_0 : t val v4_09_1 : t val v4_10_0 : t val v4_10_1 : t val v4_10_2 : t val v4_11_0 : t val v4_11_1 : t val v4_11_2 : t val v4_12_0 : t val v4_12_1 : t val v4_13_0 : t val v4_13_1 : t val v4_14_0 : t val v4_14_1 : t val v4_14_2 : t val v5_0_0 : t val v5_1_0 : t val v5_1_1 : t val v5_2_0 : t val v5_2_1 : t val v5_3_0 : t val known_versions : t list val is_known : t -> bool val is_development : t -> bool val major : t -> int val minor : t -> int val patch_level : t -> int val extra_info : t -> extra_info option val string_of_extra_info_opt : extra_info option -> string val ocaml_of_extra_info_opt : extra_info option -> string val to_string : t -> string val of_string : string -> t val compare : t -> t -> int val test : unit -> unit stdcompat-21.1/tools/dump_interfaces.sh000077500000000000000000000021041505130230400202700ustar00rootroot00000000000000#!/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 stdcompat-21.1/tools/dune000066400000000000000000000001421505130230400154370ustar00rootroot00000000000000(executable (name stdcompatpp) (modules compiler_version stdcompatpp)) (ocamllex stdcompatpp) stdcompat-21.1/tools/generate-dune-rules000077500000000000000000000017501505130230400203700ustar00rootroot00000000000000#!/bin/sh rules_file=dune-rules.inc generated_files=_generated-files write_dune_rule() { src=$1 dst=$2 echo $dst >> $generated_files case $src in *.c.in|*.h.in) source_type=c;; *) source_type=ocaml esac # echo Writing Dune rule to generate $dst from $src, source_type=$source_type cat >> $rules_file << EOF (rule (targets $dst) (deps (:gen tools/stdcompatpp.exe) $src) (action (with-stdin-from $src (with-stdout-to $dst (run %{gen} --source-type $source_type))))) EOF } genrule1() { input=$1 # echo One file: $input write_dune_rule $input.in $input } genrule2() { input=$1 src=${input##*:} dst=${input%%:*} # echo Two files: src=$src dst=$dst write_dune_rule $src $dst } rm -f $rules_file $generated_files grep CONFIG_FILES configure.ac | grep -v META | sed 's/AC_CONFIG_FILES([[]\([^]]\+\)[]])/\1/g' | \ (while read input; do case "$input" in *:*) genrule2 $input;; *) genrule1 $input;; esac; done) stdcompat-21.1/tools/interface_dumper.ml000066400000000000000000000224331505130230400204360ustar00rootroot00000000000000let 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 () stdcompat-21.1/tools/interface_dumper.mli000066400000000000000000000000001505130230400205710ustar00rootroot00000000000000stdcompat-21.1/tools/interface_generator.ml000066400000000000000000001773261505130230400211440ustar00rootroot00000000000000module 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 stdcompat-21.1/tools/interface_generator.mli000066400000000000000000000000001505130230400212630ustar00rootroot00000000000000stdcompat-21.1/tools/interface_tools.ml000066400000000000000000000071061505130230400203020ustar00rootroot00000000000000module 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 stdcompat-21.1/tools/interface_tools.mli000066400000000000000000000031421505130230400204470ustar00rootroot00000000000000module 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 stdcompat-21.1/tools/stdcompatpp.mli000066400000000000000000000002151505130230400176230ustar00rootroot00000000000000type options type lexer_state type lexer = options -> lexer_state -> Lexing.lexbuf -> unit val ocaml_lexer : lexer val c_lexer : lexer stdcompat-21.1/tools/stdcompatpp.mll000066400000000000000000000246611505130230400176410ustar00rootroot00000000000000(* Preprocesses stdcompat modules *) { let error message = Printf.eprintf "%s\n%!" message; exit 2 let unknown what arg = Printf.sprintf "Unknown %s %s" what arg |> error type source_type = OCaml | C let source_types = [ "c", C; "ocaml", OCaml; ] let start_comment language = (if language = OCaml then "(*" else "#if 0") |> print_string let end_comment language = (if language = OCaml then "*)" else "#endif") |> print_string type options = { compiler_version : Compiler_version.t; source_type : source_type; debug : bool; } let init_options () = { compiler_version = Compiler_version.of_string Sys.ocaml_version; source_type = OCaml; debug = false; } let dprintf options fmt = let printer = if options.debug then Printf.fprintf else Printf.ifprintf in printer stderr fmt let set_compiler_version opts version = let compiler_version = try Compiler_version.of_string version with _ -> unknown "compiler version" version in opts := { !opts with compiler_version } let set_source_type opts source_type = let source_type = try List.assoc source_type source_types with Not_found -> unknown "source type" source_type in opts := { !opts with source_type } let set_debug opts = opts := { !opts with debug = true } let parse_commandline options = let opts = ref options in let args = [ ("--compiler-version", Arg.String (set_compiler_version opts), " Set compiler version"); ("--source-type", Arg.String (set_source_type opts), " Set source type (ocaml or c)"); ("--debug", Arg.Unit (fun () -> set_debug opts), " Turn on debugging"); ] in Arg.parse args (unknown "argument") Sys.argv.(0); !opts type cst = Before | From | After type block_info = { start_lineno : int; (* Line number where the current block starts *) tag : string; (* tag used to start this block *) keep : bool; } type lexer_state = { lineno : int; blocks : block_info list; } let next_line state = { state with lineno = state.lineno + 1 } type lexer = options -> lexer_state -> Lexing.lexbuf -> unit let initial_lexer_state () = { lineno = 1; blocks = []; } let cst_of_string = function | "BEFORE" -> Before | "FROM" -> From | "AFTER" -> After | c -> error ("Unknown constraint " ^ c) let tag_mismatch (start_lineno, start_tag) (end_lineno, end_tag) = Printf.sprintf "Line %d: expected END_%s, got END_%s, block starts at line %d" end_lineno start_tag end_tag start_lineno |> error let check_block_end state end_tag = match state.blocks with | [] -> Printf.sprintf "Line %d: the %s block has not been started" state.lineno end_tag |> error | { start_lineno; tag = start_tag; _ } :: _ -> if start_tag <> end_tag then tag_mismatch (start_lineno, start_tag) (state.lineno, end_tag) let known_tags compiler_version = [ "BIG_ENDIAN", string_of_bool Sys.big_endian; "OCAML_DEVELOPMENT_VERSION", "false"; "OCAML_RELEASE_EXTRA", Compiler_version.ocaml_of_extra_info_opt (Compiler_version.extra_info compiler_version); "OCAML_VERSION_MAJOR", string_of_int (Compiler_version.major compiler_version); "OCAML_VERSION_MINOR", string_of_int (Compiler_version.minor compiler_version); "OCAML_VERSION_PATCHLEVEL", string_of_int (Compiler_version.patch_level compiler_version); ] let features = [ "CYGWIN", Sys.os_type = "Cygwin"; "FLAMBDA2", false; "MAGIC", true; "RESULT_PKG", true; "SEQ_PKG", true; "UCHAR_PKG", true; "UNIX", Sys.os_type = "Unix"; "WIN32", Sys.os_type = "Win32"; ] } let cst = "BEFORE"|"FROM"|"AFTER" let digit = ['0'-'9'] let number = digit+ let tag_char = ['A'-'Z''a'-'z''0'-'9''_'] let version = (number as major)'_'(number as minor)('_'(number as patch_level))? let compiler_version_constraint_block = (cst as cst) '_' (version as _version) as _tag let compiler_version_constraint_block_begin = "@BEGIN_" compiler_version_constraint_block '@' let compiler_version_constraint_c_block_begin = "@C_BEGIN_" compiler_version_constraint_block '@' let compiler_version_constraint_block_end = "@END_" compiler_version_constraint_block '@' let compiler_version_constraint_c_block_end = "@C_END_" compiler_version_constraint_block '@' let with = ("WITH"|"WITHOUT") as _enabled let feature = ((tag_char+) as _feature) let begin_feature_block = "@BEGIN_" ((with '_' feature) as _tag) '@' let end_feature_block = "@END_" ((with '_' feature) as _tag) '@' let other_tag = '@' ((tag_char+) as tag) '@' rule ocaml_lexer options state = parse | compiler_version_constraint_block_begin { dprintf options "block_begin\n%!"; let patch_level = match patch_level with | None -> "0" | Some pl -> pl in dprintf options "Line %d: start of block with cst=%s, version=%s major=%s minor=%s patch_level=%s\n%!" state.lineno cst _version major minor patch_level; let cst = cst_of_string cst in let f c = if c = '_' then '.' else c in let version = _version |> (String.map f) |> Compiler_version.of_string in let cmp = Compiler_version.compare options.compiler_version version in let keep = match cst with | Before -> cmp < 0 | From -> cmp >= 0 | After -> cmp > 0 in dprintf options "keep=%b\n%!" keep; if not keep then start_comment OCaml; let block = { start_lineno = state.lineno; tag = _tag; keep } in let state = { state with blocks = block::state.blocks } in ocaml_lexer options state lexbuf } | compiler_version_constraint_block_end { dprintf options "block_end\n%!"; let patch_level = match patch_level with | None -> "0" | Some pl -> pl in dprintf options "Line %d: end of block with cst=%s, version=%s major=%s minor=%s patch_level=%s\n%!" state.lineno cst _version major minor patch_level; check_block_end state _tag; let (keep, state) = match state.blocks with | [] -> (true, state) | block::blocks -> (block.keep, {state with blocks}) in if not keep then end_comment OCaml; ocaml_lexer options state lexbuf } | begin_feature_block { dprintf options "begin_feature_block\n%!"; if not (List.mem_assoc _feature features) then Printf.sprintf "Line %d: unknown feature %s" state.lineno _feature |> error; let keep = List.assoc _feature features in let keep = if _enabled = "WITH" then keep else not keep in if not keep then start_comment OCaml; let block = { start_lineno = state.lineno; tag = _tag; keep } in let state = { state with blocks = block::state.blocks } in ocaml_lexer options state lexbuf } | end_feature_block { dprintf options "end_feature_block\n%!"; check_block_end state _tag; let (keep, state) = match state.blocks with | [] -> (true, state) | block::blocks -> (block.keep, {state with blocks}) in if not keep then end_comment OCaml; ocaml_lexer options state lexbuf } | other_tag as quoted_tag { dprintf options "other_tag: %s\n%!" quoted_tag; (try (List.assoc tag (known_tags options.compiler_version) |> print_string) with Not_found -> Printf.sprintf "Line %d: unknknown tag %s " state.lineno quoted_tag |> error); ocaml_lexer options state lexbuf } | _ as ch { dprintf options "character: '%s'\n%!" (Char.escaped ch); print_char ch; let state = if ch='\n' then next_line state else state in ocaml_lexer options state lexbuf } | eof { dprintf options "eof\n%!"; match state.blocks with | [] -> () | block::_ -> begin let message = Printf.sprintf "The %s block started at line %d has not been ended" block.tag block.start_lineno in error message end } and c_lexer options state = parse | compiler_version_constraint_c_block_begin { dprintf options "c_block_begin\n%!"; let patch_level = match patch_level with | None -> "0" | Some pl -> pl in dprintf options "Line %d: start of block with cst=%s, version=%s major=%s minor=%s patch_level=%s\n%!" state.lineno cst _version major minor patch_level; let cst = cst_of_string cst in let f c = if c = '_' then '.' else c in let version = _version |> (String.map f) |> Compiler_version.of_string in let cmp = Compiler_version.compare options.compiler_version version in let keep = match cst with | Before -> cmp < 0 | From -> cmp >= 0 | After -> cmp > 0 in if not keep then start_comment C; let block = { start_lineno = state.lineno; tag = _tag; keep } in let state = { state with blocks = block::state.blocks } in c_lexer options state lexbuf } | compiler_version_constraint_c_block_end { dprintf options "c_block_end\n%!"; let patch_level = match patch_level with | None -> "0" | Some pl -> pl in dprintf options "Line %d: end of block with cst=%s, version=%s major=%s minor=%s patch_level=%s\n%!" state.lineno cst _version major minor patch_level; check_block_end state _tag; let (keep, state) = match state.blocks with | [] -> (true, state) | block::blocks -> (block.keep, {state with blocks}) in if not keep then end_comment C; c_lexer options state lexbuf } | other_tag as quoted_tag { dprintf options "other_tag: %s\n%!" quoted_tag; try (List.assoc tag (known_tags options.compiler_version)) |> print_string with Not_found -> Printf.sprintf "Line %d: unknknown tag %s " state.lineno quoted_tag |> error } | _ as ch { dprintf options "char: '%s'\n%!" (Char.escaped ch); print_char ch; let state = if ch='\n' then next_line state else state in c_lexer options state lexbuf } | eof { dprintf options "eof\n%!"; match state.blocks with | [] -> () | block::_ -> begin let message = Printf.sprintf "The %s block started at line %d has not been ended" block.tag block.start_lineno in error message end } { let main () = let options = init_options () |> parse_commandline in let lexer = match options.source_type with | OCaml -> ocaml_lexer | C -> c_lexer in let state = initial_lexer_state () in Lexing.from_channel stdin |> lexer options state let _ = main () } stdcompat-21.1/tools/test_all_switches.sh000077500000000000000000000004031505130230400206400ustar00rootroot00000000000000#!/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