pax_global_header00006660000000000000000000000064135047125640014521gustar00rootroot0000000000000052 comment=e3c733c3aa14f24ed7904a4788c6f03eab1b41af stdcompat-10/000077500000000000000000000000001350471256400133015ustar00rootroot00000000000000stdcompat-10/.gitignore000066400000000000000000000006711350471256400152750ustar00rootroot00000000000000_build/ *.install .merlin *~ *.[ao] *.cm[aiotx] *.cmti *.cmx[as] /Makefile /Makefile.in /aclocal.m4 /autom4te.cache /doc/ /tests.bytecode /tests.native /META /stdcompat.ml_byte /stdcompat.ml_native /.depend /stdcompat_*.ml /stdcompat_*.mli /configure /interface_generator/interface_dumper /interface_generator/interface_generator /interface_generator/.depend /stdcompat.ml /stdcompat.mli /config.guess /config.log /config.status /config.sub stdcompat-10/AUTHORS000066400000000000000000000000541350471256400143500ustar00rootroot00000000000000Thierry Martinez stdcompat-10/COPYING000066400000000000000000000027501350471256400143400ustar00rootroot00000000000000Copyright 1992-2016 The FreeBSD Project. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 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 AUTHOR 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 AUTHOR 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. The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of the FreeBSD Project. stdcompat-10/ChangeLog000066400000000000000000000106671350471256400150650ustar00rootroot00000000000000* Version 10 - 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 - [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 - 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 - 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 - Support for OCaml 4.08.0 - Support VPATH build, i.e. when configure is executed in a build directory distinct from the source directory - Lexing.new_line - Bigarray: only available from 4.02.0. From 4.02.0 and before 4.07.0, --no-alias-deps is used to allow the alias to appear in Stdcompat without requiring the library to be linked. Bigarray library should be linked if it is effectively used. - Fix implementations with --disable-magic - Fix license conflict: The project was intended to be under BSD license since the beginning, and a LICENSE file was provided accordingly. However, automake generated a COPYING file with the GPLv3 by default. The COPYING file now contains the BSD license, and the LICENSE file is removed. (reported by Török Edwin, https://github.com/thierry-martinez/stdcompat/issues/5) - Fix auto-generated interfaces for Hashtbl.MakeSeeded - Exceptions are reexported again. They were missing in auto-generated interfaces. - min_binding_opt and max_binding_opt are not redefined if OCaml >=4.05. - Array.of_seq is redefined in OCaml 4.07.0 to circumvent a bug in the implementation of the standard library. See: - https://caml.inria.fr/mantis/view.php?id=7820 - https://github.com/ocaml/ocaml/pull/1897 * Version 5 - Interfaces are auto-generated. - stdcompat is now free from any required dependency. There are still optional dependencies with respect to the packages result, seq and uchar: stdcompat takes care of providing types compatible with these packages if they are installed. - Preprocessing is performed by "./configure" script (generated by autoconf). cppo and the C preprocessor are no longer used. - Makefile is generated by automake. ocamlfind is no longer required for installation. - Split implementation into one module for each standard library module (suggested by Yotam Barnoy: https://github.com/thierry-martinez/stdcompat/issues/4) - All modules are now exported as sub-modules of Stdlib module (as in OCaml 4.07) -- Bigarray is not exported to allow programs not to be compiled with this module, this may change in the future. (suggested by Yotam Barnoy: https://github.com/thierry-martinez/stdcompat/issues/4) - Compatibility with uchar package * Version 4 - Fix link problems with hypot, copy_sign, ldexp and classify_float * Version 3 - Missing List.of_seq/List.to_seq - Remove spurious Float.seeded_hash_param (suggested by Hezekiah M. Carty: https://github.com/thierry-martinez/stdcompat/pull/2) - Compatibility with seq and result packages (suggested by Hezekiah M. Carty: https://github.com/thierry-martinez/stdcompat/issues/1) - Magic implementations of {Set,Map,Hashtbl,Queue,Stack}.to_seq*, Hashtbl.filter_map_inplace, Hashtbl.stats, Stack.fold, Set.find*, Set.map. Pure implementations are available by building with "make USE_MAGIC=false" - jbuild script (Hezekiah M. Carty) * Version 2 - 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 : initial release stdcompat-10/Dockerfile000066400000000000000000000022231350471256400152720ustar00rootroot00000000000000FROM ubuntu:16.04 RUN apt update; echo yes | apt install autoconf automake unzip aspcud rsync \ git mercurial darcs wget build-essential sudo vim curl RUN useradd -m -s /bin/bash ci Run echo ci ALL=\(ALL\) NOPASSWD:ALL >/etc/sudoers USER ci RUN wget -O ~/opam https://github.com/ocaml/opam/releases/download/2.0.1/opam-2.0.1-x86_64-linux RUN chmod +x ~/opam RUN sudo mv ~/opam /usr/local/bin/opam RUN opam init --disable-sandboxing --auto-setup 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.0 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.0stdcompat-10/INSTALL000066400000000000000000000366141350471256400143440ustar00rootroot00000000000000Installation 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-10/Jenkinsfile000066400000000000000000000041471350471256400154730ustar00rootroot00000000000000properties([ [ $class: 'ThrottleJobProperty', categories: ['category'], limitOneJobWithMatchingParams: false, maxConcurrentPerNode: 4, maxConcurrentTotal: 0, paramsToUseForLimit: '', throttleEnabled: true, throttleOption: 'category' ], ]) pipeline { agent { /* dockerfile { label 'slave' } */ label 'slave' } stages { stage('Prepare') { steps { sh 'docker build -t stdcompat .' } } stage('Build') { steps { sh 'docker run --rm --volume $PWD:/workspace stdcompat sh -c \'cd /workspace && eval `opam config env` && autoreconf && mkdir build && cd build && ../configure && make\'' } } stage('Test') { steps { script { def pwd = sh ( script: 'echo $PWD', returnStdout: true ).trim() def switches = sh ( script: 'docker run --rm stdcompat opam switch -s', returnStdout: true ).split('\n') def branches = [:] for (i in switches) { def switch_name = i branches[switch_name] = { node { sh "docker run --rm --volume $pwd:/workspace stdcompat sh -c 'cd /workspace && opam config exec --switch $switch_name -- sh -c '\\''mkdir build/$switch_name && cd build/$switch_name && ../../configure && make && make tests && ../../configure --disable-magic && make && make tests'\\'" } } } throttle(['category']) { parallel branches } } } } stage('Deploy') { steps { sh 'cd build && make dist' archiveArtifacts artifacts: 'build/*.tar.gz', fingerprint: true } } } } stdcompat-10/META.in000066400000000000000000000003241350471256400143560ustar00rootroot00000000000000description = "Stdcompat: compatibility module for OCaml standard library" requires = "@SEQ_PKG@ @RESULT_PKG@ @UCHAR_PKG@" version = "@VERSION@" archive(byte) = "stdcompat.cma" archive(native) = "stdcompat.cmxa" stdcompat-10/Makefile.am000066400000000000000000000127641350471256400153470ustar00rootroot00000000000000ACLOCAL_AMFLAGS = -I m4 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__stream.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__spacetime.mli stdcompat__moreLabels.mli stdcompat__lexing.mli \ stdcompat__option.mli stdcompat__printexc.mli stdcompat__result.mli stdcompat__bool.mli \ stdcompat__fun.mli stdcompat__format.mli stdcompat__printf.mli stdcompat__stdlib.mli \ stdcompat__seq.mli stdcompat__printexc.mli MODULES = stdcompat__init.ml stdcompat__root.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__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__hashtbl_s.ml stdcompat__set_s.ml \ stdcompat__map_s.ml stdcompat__weak_s.ml stdcompat__sys_s.ml \ stdcompat__stream_s.ml stdcompat__digest_s.ml stdcompat__nativeint_s.ml \ stdcompat__int_s.ml \ stdcompat__int64_s.ml stdcompat__int32_s.ml stdcompat__filename_s.ml \ stdcompat__array_s.ml stdcompat__arrayLabels_s.ml \ stdcompat__float_s.ml stdcompat__queue_s.ml stdcompat__ephemeron_s.ml \ stdcompat__spacetime_s.ml stdcompat__moreLabels_s.ml stdcompat__lexing_s.ml \ stdcompat__option_s.ml stdcompat__result_s.ml stdcompat__bool_s.ml \ stdcompat__fun_s.ml stdcompat__stdlib_s.ml stdcompat__printf_s.ml \ stdcompat__printexc_s.ml \ stdcompat__pervasives.ml stdcompat__arg.ml stdcompat__lazy.ml \ stdcompat__char.ml stdcompat__uchar.ml stdcompat__sys.ml stdcompat__buffer.ml \ stdcompat__string.ml stdcompat__stringLabels.ml stdcompat__bytes.ml \ stdcompat__bytesLabels.ml stdcompat__list.ml stdcompat__listLabels.ml \ stdcompat__stack.ml stdcompat__hashtbl_ext.ml \ stdcompat__hashtbl.ml stdcompat__set.ml \ stdcompat__map.ml stdcompat__weak.ml \ stdcompat__stream.ml stdcompat__digest.ml stdcompat__nativeint.ml \ stdcompat__int.ml \ stdcompat__int64.ml stdcompat__int32.ml stdcompat__filename.ml \ stdcompat__array.ml stdcompat__arrayLabels.ml \ stdcompat__float.ml stdcompat__queue.ml stdcompat__ephemeron.ml \ stdcompat__spacetime.ml stdcompat__moreLabels.ml stdcompat__lexing.ml \ stdcompat__option.ml stdcompat__printexc.ml stdcompat__result.ml stdcompat__bool.ml \ stdcompat__fun.ml stdcompat__format.ml stdcompat__printf.ml stdcompat__stdlib.ml \ stdcompat.ml MODULES_native = stdcompat__native.ml $(MODULES) mypkg_SCRIPTS = META $(MODULES_native) $(MODULES_native:.ml=.cmi) \ libstdcompat__stubs.a if OCAML_SUPPORTS_BYTECODE mypkg_SCRIPTS += stdcompat.cma endif if OCAML_SUPPORTS_NATIVE mypkg_SCRIPTS += stdcompat.cmxa stdcompat.a $(MODULES_native:.ml=.cmx) endif if OCAML_SUPPORTS_SHARED mypkg_SCRIPTS += stdcompat.cmxs endif PACKAGES = $(RESULT_PKG) $(SEQ_PKG) $(UCHAR_PKG) OCAMLFLAGS = $(PACKAGES:%=-package %) OCAMLCFLAGS = $(OCAMLFLAGS) -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 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 $@ stdcompat__stubs.o : stdcompat__stubs.c $(OCAMLC) -c -o $@ $< libstdcompat__stubs.a : stdcompat__stubs.o $(OCAMLMKLIB) -o $(basename $<) $< stdcompat.cma : $(MODULES_native:.ml=.cmo) libstdcompat__stubs.a $(OCAMLC) $(OCAMLLDFLAGS) -a $(MODULES_native:.ml=.cmo) $(OCAMLLIBFLAGS) -o $@ stdcompat.cmxa : $(MODULES_native:.ml=.cmx) libstdcompat__stubs.a $(OCAMLOPT) $(OCAMLLDFLAGS) -a $(MODULES_native:.ml=.cmx) $(OCAMLLIBFLAGS) -o $@ stdcompat.a : stdcompat.cmxa stdcompat.cmxs : $(MODULES_native:.ml=.cmx) libstdcompat__stubs.a $(OCAMLOPT) $(OCAMLLDFLAGS) -shared $(MODULES_native:.ml=.cmx) $(OCAMLLIBFLAGS) -o $@ stdcompat__native.cmo : stdcompat__native.ml_byte $(OCAMLC) $(OCAMLCFLAGS) -c -impl stdcompat__native.ml_byte stdcompat__native.cmx : stdcompat__native.ml_native $(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 : tests tests : stdcompat_tests ./stdcompat_tests stdcompat_tests: stdcompat.$(CMAX) stdcompat_tests.ml $(OCAMLBEST) stdcompat.$(CMAX) stdcompat_tests.ml -o $@ @INCLUDE_DEPEND@ CLEANFILES = *.cmi *.cmo *.cmx *.cmt *.cmti *.o *.a stdcompat.cma \ stdcompat.cmxa stdcompat__native.ml \ stdcompat.cmxs stdcompat_tests $(bin_SCRIPTS) .depend stdcompat-10/Makefile.config.in000066400000000000000000000002731350471256400166140ustar00rootroot00000000000000OCAMLFIND := @OCAMLFIND@ OCAMLOPT := @OCAMLOPT@ OCAMLC := @OCAMLC@ OCAMLDOC := @OCAMLDOC@ OCAMLBEST := @OCAMLBEST@ RESULT_PKG := @RESULT_PKG@ SEQ_PKG := @SEQ_PKG@ UCHAR_PKG := @UCHAR_PKG@stdcompat-10/NEWS000066400000000000000000000000151350471256400137740ustar00rootroot00000000000000See ChangeLogstdcompat-10/README000077700000000000000000000000001350471256400154332README.mdustar00rootroot00000000000000stdcompat-10/README.md000066400000000000000000000071271350471256400145670ustar00rootroot00000000000000``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.07 (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``. Note that redefinitions can still have bad time complexity: for instance, ``Set.map`` uses the function ``union`` to rebuild trees instead of the internal function ``try_join``, because using the latter would require to redefine too much internal functions. 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. stdcompat-10/compile000077500000000000000000000163271350471256400146700ustar00rootroot00000000000000#! /bin/sh # Wrapper for compilers which do not understand '-c -o'. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1999-2018 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*) 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/*) 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-10/configure.ac000066400000000000000000000251641350471256400155770ustar00rootroot00000000000000AC_INIT([[stdcompat]], [10], [[Thierry.Martinez@inria.fr]], [[stdcompat]], [[https://github.com/thierry.martinez/stdcompat/]]) AM_INIT_AUTOMAKE AC_DEFUN([AC_OCAMLFIND_PKG], [AC_MSG_CHECKING([for ocamlfind package $2]) AS_IF([$OCAMLFIND query $2 >/dev/null 2>&1], [AC_MSG_RESULT([yes]) AC_SUBST([$1], [$2])], [AC_MSG_RESULT([no]) AC_SUBST([$1], [])])]) AC_CHECK_TOOL([OCAMLFIND], [ocamlfind], []) AS_IF([test "x$OCAMLFIND" = "x"], [AC_CHECK_TOOL([OCAMLC], [ocamlc.opt], []) AS_IF([test "x$OCAMLC" = "x"], [AC_CHECK_TOOL([OCAMLC], [ocamlc], [])]) AC_CHECK_TOOL([OCAMLOPT], [ocamlopt.opt], []) AS_IF([test "x$OCAMLOPT" = "x"], [AC_CHECK_TOOL([OCAMLOPT], [ocamlopt], [])]) AC_CHECK_TOOL([OCAMLDOC], [ocamldoc.opt], []) AS_IF([test "x$OCAMLDOC" = "x"], [AC_CHECK_TOOL([OCAMLDOC], [ocamldoc], [])]) AC_CHECK_TOOL([OCAMLDEP], [ocamldep.opt], []) AS_IF([test "x$OCAMLDEP" = "x"], [AC_CHECK_TOOL([OCAMLDEP], [ocamldep], [])]) AC_CHECK_TOOL([OCAMLMKLIB], [ocamlmklib.opt], []) AS_IF([test "x$OCAMLMKLIB" = "x"], [AC_CHECK_TOOL([OCAMLMKLIB], [ocamlmklib], [])]) AC_SUBST([RESULT_PKG], []) AC_SUBST([SEQ_PKG], []) AC_SUBST([UCHAR_PKG], [])], [AC_SUBST([OCAMLC], [["$OCAMLFIND ocamlc"]]) AC_SUBST([OCAMLOPT], [["$OCAMLFIND ocamlopt"]]) AC_SUBST([OCAMLDOC], [["$OCAMLFIND ocamldoc"]]) AC_SUBST([OCAMLDEP], [["$OCAMLFIND ocamldep"]]) AC_SUBST([OCAMLMKLIB], [["$OCAMLFIND ocamlmklib"]]) AC_OCAMLFIND_PKG([RESULT_PKG], [result]) AC_OCAMLFIND_PKG([SEQ_PKG], [seq]) AC_OCAMLFIND_PKG([UCHAR_PKG], [uchar])]) AS_IF([test "x$OCAMLOPT" = "x"], [AS_IF([test "x$OCAMLC" = "x"], [AC_MSG_ERROR([[No OCaml compiler available]])], [AC_SUBST([OCAMLBEST], [["$OCAMLC"]]) AC_SUBST([CMAX], [["cma"]])])], [AC_SUBST([OCAMLBEST], [["$OCAMLOPT"]]) AC_SUBST([CMAX], [["cmxa"]])]) AS_IF([test "x$OCAMLDEP" = "x"], [AC_MSG_ERROR([[No ocamldep available]])]) AC_C_BIGENDIAN( [AC_SUBST([BIG_ENDIAN], [[true]])], [AC_SUBST([BIG_ENDIAN], [[false]])], [AC_MSG_ERROR([[Unknown endianness]])]) AC_MSG_CHECKING([OCaml version]) AC_SUBST([OCAMLVERSION], [[`$OCAMLBEST -v | sed -n 's/^.*version \(.*\)$/\1/p'`]]) AC_MSG_RESULT([$OCAMLVERSION]) 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], [['/*']]) AC_SUBST([C_END_$1], [['*/']])]) AC_DEFUN([AC_ENABLE_BLOCK], [AC_SUBST([BEGIN_$1], []) AC_SUBST([END_$1], []) AC_SUBST([C_BEGIN_$1], []) AC_SUBST([C_END_$1], [])]) AC_DEFUN([AC_WITH_BLOCK], [AC_ENABLE_BLOCK([WITH_$1]) AC_DISABLE_BLOCK([WITHOUT_$1])]) AC_DEFUN([AC_WITHOUT_BLOCK], [AC_DISABLE_BLOCK([WITH_$1]) AC_ENABLE_BLOCK([WITHOUT_$1])]) AC_DEFUN([AC_WITH_BLOCK_PKG], [AS_IF([test "x$$1_PKG" = "x"], [AC_WITHOUT_BLOCK($1_PKG)], [AC_WITH_BLOCK($1_PKG)])]) AC_DEFUN([AC_WITH_OCAML_VERSION], [AS_IF([test `printf "$OCAMLVERSION\n$2" | sort | head -n1` = $2], [AC_ENABLE_BLOCK([FROM_$1]) AC_DISABLE_BLOCK([BEFORE_$1])], [AC_DISABLE_BLOCK([FROM_$1]) AC_ENABLE_BLOCK([BEFORE_$1])])]) AS_IF([test "x$enable_magic" = "xno"], [AC_WITHOUT_BLOCK([MAGIC])], [AC_WITH_BLOCK([MAGIC])]) AC_WITH_BLOCK_PKG([RESULT]) AC_WITH_BLOCK_PKG([SEQ]) AC_WITH_BLOCK_PKG([UCHAR]) AC_WITH_OCAML_VERSION([3_07_0], [3.07]) AC_WITH_OCAML_VERSION([3_08_0], [3.08.0]) AC_WITH_OCAML_VERSION([3_09_0], [3.09.0]) AC_WITH_OCAML_VERSION([3_10_0], [3.10.0]) AC_WITH_OCAML_VERSION([3_11_0], [3.11.0]) AC_WITH_OCAML_VERSION([3_12_0], [3.12.0]) AC_WITH_OCAML_VERSION([4_00_0], [4.00.0]) AC_WITH_OCAML_VERSION([4_01_0], [4.01.0]) AC_WITH_OCAML_VERSION([4_02_0], [4.02.0]) AC_WITH_OCAML_VERSION([4_03_0], [4.03.0]) AC_WITH_OCAML_VERSION([4_04_0], [4.04.0]) AC_WITH_OCAML_VERSION([4_05_0], [4.05.0]) AC_WITH_OCAML_VERSION([4_06_0], [4.06.0]) AC_WITH_OCAML_VERSION([4_07_0], [4.07.0]) AC_WITH_OCAML_VERSION([4_07_1], [4.07.1]) AC_WITH_OCAML_VERSION([4_08_0], [4.08.0]) 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]) 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]) AC_SUBST([INCLUDE_DEPEND],[[' ifneq ($(MAKECMDGOALS),clean) ifneq ($(MAKECMDGOALS),distclean) include .depend endif endif ']]) AC_CONFIG_FILES([ META Makefile stdcompat__hashtbl_ext.mli stdcompat__hashtbl_ext.ml stdcompat__init.mli stdcompat__init.ml stdcompat__root.mli stdcompat__root.ml stdcompat__tools.mli stdcompat__tools.ml stdcompat__native.ml_byte stdcompat__native.ml_native stdcompat_tests.ml stdcompat__stubs.c stdcompat__pervasives_s.mli stdcompat__arg_s.mli stdcompat__array_s.mli stdcompat__arrayLabels_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__ephemeron_s.mli stdcompat__filename_s.mli stdcompat__float_s.mli stdcompat__format_s.mli stdcompat__fun_s.mli stdcompat__hashtbl_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__printexc_s.mli stdcompat__printf_s.mli stdcompat__queue_s.mli stdcompat__result_s.mli stdcompat__seq_s.mli stdcompat__set_s.mli stdcompat__spacetime_s.mli stdcompat__stack_s.mli stdcompat__stream_s.mli stdcompat__string_s.mli stdcompat__stringLabels_s.mli stdcompat__sys_s.mli stdcompat__uchar_s.mli stdcompat__weak_s.mli stdcompat__stdlib_s.mli stdcompat__pervasives_s.ml:stdcompat__pervasives_s.mli.in stdcompat__arg_s.ml:stdcompat__arg_s.mli.in stdcompat__array_s.ml:stdcompat__array_s.mli.in stdcompat__arrayLabels_s.ml:stdcompat__arrayLabels_s.mli.in stdcompat__bool_s.ml:stdcompat__bool_s.mli.in stdcompat__buffer_s.ml:stdcompat__buffer_s.mli.in stdcompat__bytes_s.ml:stdcompat__bytes_s.mli.in stdcompat__bytesLabels_s.ml:stdcompat__bytesLabels_s.mli.in stdcompat__char_s.ml:stdcompat__char_s.mli.in stdcompat__digest_s.ml:stdcompat__digest_s.mli.in stdcompat__ephemeron_s.ml:stdcompat__ephemeron_s.mli.in stdcompat__filename_s.ml:stdcompat__filename_s.mli.in stdcompat__float_s.ml:stdcompat__float_s.mli.in stdcompat__format_s.ml:stdcompat__format_s.mli.in stdcompat__fun_s.ml:stdcompat__fun_s.mli.in stdcompat__hashtbl_s.ml:stdcompat__hashtbl_s.mli.in stdcompat__int_s.ml:stdcompat__int_s.mli.in stdcompat__int32_s.ml:stdcompat__int32_s.mli.in stdcompat__int64_s.ml:stdcompat__int64_s.mli.in stdcompat__lazy_s.ml:stdcompat__lazy_s.mli.in stdcompat__lexing_s.ml:stdcompat__lexing_s.mli.in stdcompat__list_s.ml:stdcompat__list_s.mli.in stdcompat__listLabels_s.ml:stdcompat__listLabels_s.mli.in stdcompat__map_s.ml:stdcompat__map_s.mli.in stdcompat__moreLabels_s.ml:stdcompat__moreLabels_s.mli.in stdcompat__nativeint_s.ml:stdcompat__nativeint_s.mli.in stdcompat__option_s.ml:stdcompat__option_s.mli.in stdcompat__printexc_s.ml:stdcompat__printexc_s.mli.in stdcompat__printf_s.ml:stdcompat__printf_s.mli.in stdcompat__queue_s.ml:stdcompat__queue_s.mli.in stdcompat__result_s.ml:stdcompat__result_s.mli.in stdcompat__seq_s.ml:stdcompat__seq_s.mli.in stdcompat__set_s.ml:stdcompat__set_s.mli.in stdcompat__spacetime_s.ml:stdcompat__spacetime_s.mli.in stdcompat__stack_s.ml:stdcompat__stack_s.mli.in stdcompat__stdlib_s.ml:stdcompat__stdlib_s.mli.in stdcompat__stream_s.ml:stdcompat__stream_s.mli.in stdcompat__string_s.ml:stdcompat__string_s.mli.in stdcompat__stringLabels_s.ml:stdcompat__stringLabels_s.mli.in stdcompat__sys_s.ml:stdcompat__sys_s.mli.in stdcompat__uchar_s.ml:stdcompat__uchar_s.mli.in stdcompat__weak_s.ml:stdcompat__weak_s.mli.in stdcompat__pervasives.ml stdcompat__arg.ml stdcompat__array.ml stdcompat__arrayLabels.ml stdcompat__bool.ml stdcompat__buffer.ml stdcompat__bytes.ml stdcompat__bytesLabels.ml stdcompat__char.ml stdcompat__digest.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__result.ml stdcompat__seq.ml stdcompat__set.ml stdcompat__spacetime.ml stdcompat__stack.ml stdcompat__stdlib.ml stdcompat__stream.ml stdcompat__string.ml stdcompat__stringLabels.ml stdcompat__sys.ml stdcompat__uchar.ml stdcompat__weak.ml stdcompat__pervasives.mli stdcompat__arg.mli stdcompat__array.mli stdcompat__arrayLabels.mli stdcompat__bool.mli stdcompat__buffer.mli stdcompat__bytes.mli stdcompat__bytesLabels.mli stdcompat__char.mli stdcompat__digest.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__result.mli stdcompat__seq.mli stdcompat__set.mli stdcompat__spacetime.mli stdcompat__stack.mli stdcompat__stdlib.mli stdcompat__stream.mli stdcompat__string.mli stdcompat__stringLabels.mli stdcompat__sys.mli stdcompat__uchar.mli stdcompat__weak.mli stdcompat.mli 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-10/dune000066400000000000000000000113101350471256400141530ustar00rootroot00000000000000(library (name stdcompat) (public_name stdcompat) (modules stdcompat__native stdcompat__init stdcompat__root stdcompat__seq stdcompat__tools stdcompat__pervasives stdcompat__arg stdcompat__lazy stdcompat__char stdcompat__uchar stdcompat__buffer stdcompat__string stdcompat__stringLabels stdcompat__bytes stdcompat__bytesLabels stdcompat__list stdcompat__listLabels stdcompat__stack stdcompat__hashtbl_ext stdcompat__hashtbl stdcompat__set stdcompat__map stdcompat__weak stdcompat__sys stdcompat__stream stdcompat__digest stdcompat__nativeint stdcompat__int64 stdcompat__int32 stdcompat__filename stdcompat__array stdcompat__arrayLabels stdcompat__float stdcompat__queue stdcompat__ephemeron stdcompat__spacetime stdcompat__moreLabels stdcompat)) (executable (name stdcompat_tests) (modules stdcompat_tests) (libraries stdcompat)) (rule (targets stdcompat__native.ml) (deps (:source stdcompat__native.ml_native)) (action (run cp %{source} %{targets}))) (rule (targets META Makefile stdcompat__init.mli stdcompat__hashtbl_ext.mli stdcompat__root.mli stdcompat__tools.mli stdcompat__pervasives.mli stdcompat__arg.mli stdcompat__array.mli stdcompat__arrayLabels.mli stdcompat__buffer.mli stdcompat__bytes.mli stdcompat__bytesLabels.mli stdcompat__char.mli stdcompat__digest.mli stdcompat__ephemeron.mli stdcompat__filename.mli stdcompat__float.mli stdcompat__hashtbl.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__queue.mli stdcompat__seq.mli stdcompat__set.mli stdcompat__spacetime.mli stdcompat__stack.mli stdcompat__stream.mli stdcompat__string.mli stdcompat__stringLabels.mli stdcompat__sys.mli stdcompat__uchar.mli stdcompat__weak.mli stdcompat__init.ml stdcompat__hashtbl_ext.ml stdcompat__root.ml stdcompat__tools.ml stdcompat__pervasives.ml stdcompat__arg.ml stdcompat__array.ml stdcompat__arrayLabels.ml stdcompat__buffer.ml stdcompat__bytes.ml stdcompat__bytesLabels.ml stdcompat__char.ml stdcompat__digest.ml stdcompat__ephemeron.ml stdcompat__filename.ml stdcompat__float.ml stdcompat__hashtbl.ml stdcompat__int32.ml stdcompat__int64.ml stdcompat__lazy.ml stdcompat__list.ml stdcompat__listLabels.ml stdcompat__map.ml stdcompat__moreLabels.ml stdcompat__nativeint.ml stdcompat__queue.ml stdcompat__seq.ml stdcompat__set.ml stdcompat__spacetime.ml stdcompat__stack.ml stdcompat__stream.ml stdcompat__string.ml stdcompat__stringLabels.ml stdcompat__sys.ml stdcompat__uchar.ml stdcompat__weak.ml) (deps (:configure configure) META.in Makefile.in stdcompat__init.mli.in stdcompat__hashtbl_ext.mli.in stdcompat__root.mli.in stdcompat__tools.mli.in stdcompat__pervasives.mli.in stdcompat__arg.mli.in stdcompat__array.mli.in stdcompat__arrayLabels.mli.in stdcompat__buffer.mli.in stdcompat__bytes.mli.in stdcompat__bytesLabels.mli.in stdcompat__char.mli.in stdcompat__digest.mli.in stdcompat__ephemeron.mli.in stdcompat__filename.mli.in stdcompat__float.mli.in stdcompat__hashtbl.mli.in stdcompat__int32.mli.in stdcompat__int64.mli.in stdcompat__lazy.mli.in stdcompat__lexing.mli.in stdcompat__list.mli.in stdcompat__listLabels.mli.in stdcompat__map.mli.in stdcompat__moreLabels.mli.in stdcompat__nativeint.mli.in stdcompat__queue.mli.in stdcompat__seq.mli.in stdcompat__set.mli.in stdcompat__spacetime.mli.in stdcompat__stack.mli.in stdcompat__stream.mli.in stdcompat__string.mli.in stdcompat__stringLabels.mli.in stdcompat__sys.mli.in stdcompat__uchar.mli.in stdcompat__weak.mli.in stdcompat__init.ml.in stdcompat__hashtbl_ext.ml.in stdcompat__root.ml.in stdcompat__tools.ml.in stdcompat__pervasives.ml.in stdcompat__arg.ml.in stdcompat__array.ml.in stdcompat__arrayLabels.ml.in stdcompat__buffer.ml.in stdcompat__bytes.ml.in stdcompat__bytesLabels.ml.in stdcompat__char.ml.in stdcompat__digest.ml.in stdcompat__ephemeron.ml.in stdcompat__filename.ml.in stdcompat__float.ml.in stdcompat__hashtbl.ml.in stdcompat__int32.ml.in stdcompat__int64.ml.in stdcompat__lazy.ml.in stdcompat__list.ml.in stdcompat__listLabels.ml.in stdcompat__map.ml.in stdcompat__moreLabels.ml.in stdcompat__nativeint.ml.in stdcompat__queue.ml.in stdcompat__seq.ml.in stdcompat__set.ml.in stdcompat__spacetime.ml.in stdcompat__stack.ml.in stdcompat__stream.ml.in stdcompat__string.ml.in stdcompat__stringLabels.ml.in stdcompat__sys.ml.in stdcompat__uchar.ml.in stdcompat__weak.ml.in) (action (run %{configure})))stdcompat-10/dune-project000066400000000000000000000000201350471256400156130ustar00rootroot00000000000000(lang dune 1.0) stdcompat-10/generate_interfaces.sh000077500000000000000000000020541350471256400176360ustar00rootroot00000000000000#!/usr/bin/env bash set -e opam config exec --switch=4.07.0+rc1 -- \ ocamlfind ocamlc -g -package unix,compiler-libs.common -linkpkg \ interface_generator.ml -o interface_generator for module in \ Pervasives Arg Array ArrayLabels Buffer Bytes BytesLabels Callback Char \ Complex Digest Ephemeron Filename Float Format Gc Genlex Hashtbl Int32 \ Int64 Lazy Lexing List ListLabels Map Marshal MoreLabels Nativeint Obj Oo \ Option Parsing Printexc Printf Queue Random Result Scanf Seq Set Sort \ Spacetime Stack StdLabels Stream String StringLabels Sys Uchar Weak; do target=stdcompat__`echo $module | tr A-Z a-z`.mli.in echo $module ./interface_generator $module \ ~/.opam/4.07.0+rc1/bin/ocaml \ ~/.opam/4.06.1/bin/ocaml \ ~/.opam/4.05.0/bin/ocaml \ ~/.opam/4.04.2/bin/ocaml \ ~/.opam/4.03.0/bin/ocaml \ ~/.opam/4.02.3/bin/ocaml \ ~/.opam/4.01.0/bin/ocaml \ ~/.opam/4.00.1/bin/ocaml \ ~/.opam/3.12.1/bin/ocaml \ ~/.opam/3.11.2/bin/ocaml >$target done stdcompat-10/install-sh000077500000000000000000000360101350471256400153050ustar00rootroot00000000000000#!/bin/sh # install - install a program, script, or datafile scriptversion=2018-03-11.20; # 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 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 the last 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. -s $stripprog installed files. -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 " 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;; -s) stripcmd=$stripprog;; -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=$? 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 '') # Create intermediate dirs using mode 755 as modified by the umask. # This is like FreeBSD 'install' as of 1997-10-28. umask=`umask` case $stripcmd.$umask in # Optimize common cases. *[2367][2367]) mkdir_umask=$umask;; .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; *[0-7]) mkdir_umask=`expr $umask + 22 \ - $umask % 100 % 40 + $umask % 20 \ - $umask % 10 % 4 + $umask % 2 `;; *) mkdir_umask=$umask,go-w;; esac # 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 case $umask in *[123567][0-7][0-7]) # POSIX mkdir -p sets u+wx bits regardless of umask, which # is incompatible with FreeBSD 'install' when (umask & 300) != 0. ;; *) # Note that $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' feature. 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;; esac if $posix_mkdir && ( umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ) then : else # The umask is ridiculous, or 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 && $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 # 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 -f "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && { $doit $rmcmd -f "$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-10/interface_generator/000077500000000000000000000000001350471256400173075ustar00rootroot00000000000000stdcompat-10/interface_generator/Makefile000066400000000000000000000037031350471256400207520ustar00rootroot00000000000000OCAMLFIND := 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 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-10/interface_generator/dump_interfaces.sh000077500000000000000000000020011350471256400230070ustar00rootroot00000000000000#!/usr/bin/env bash set -e #for ocaml_version in \ # 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.0+trunk; do # target_dir=../interfaces/${ocaml_version:0:4} ocaml_version=ocaml-variants.4.08.0+beta1 target_dir=../interfaces/4.08.0 mkdir -p $target_dir for module in \ Pervasives Stdlib Arg Array ArrayLabels Bool Buffer Bytes BytesLabels Callback Char \ Complex Digest Ephemeron Filename Float Format Fun Gc Genlex Hashtbl Int32 \ Int64 Lazy Lexing List ListLabels Map Marshal MoreLabels Nativeint Obj \ Oo Option Parsing Printexc Printf Queue Random Result Scanf Seq Set \ Spacetime Stack StdLabels Stream String StringLabels Sys Uchar Weak; do target=$target_dir/`echo ${module:0:1} | tr A-Z a-z`${module:1}.mli opam config 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-10/interface_generator/generate_interfaces.sh000077500000000000000000000014671350471256400236530ustar00rootroot00000000000000#!/usr/bin/env bash set -e for module in \ Arg Array ArrayLabels Bool Buffer Bytes BytesLabels Callback Char \ Complex Digest Ephemeron Filename Float Format Fun Gc Genlex Hashtbl Int32 \ Int64 Lazy Lexing List ListLabels Map Marshal MoreLabels Nativeint Obj Oo \ Option Parsing Printexc Printf Queue Random Result Scanf Seq Set Spacetime \ Stack StdLabels Stream String StringLabels Sys Uchar Weak; do echo $module target=../stdcompat__`echo $module | tr A-Z a-z`_s.mli.in ./interface_generator $module 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 >$target target=../stdcompat__`echo $module | tr A-Z a-z`_s.ml.in ./interface_generator $module 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 >$target done stdcompat-10/interface_generator/interface_dumper.ml000066400000000000000000000227341350471256400231650ustar00rootroot00000000000000let run_interpreter ?(buffer_size = 4096) ~command_line ~module_name commander = let channels = Unix.open_process_full command_line (Unix.environment ()) in Interface_tools.try_close ~close:(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 Interface_tools.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 | exception Syntaxerr.Error(err) -> prerr_endline s; Syntaxerr.report_error Format.err_formatter err; { 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 = [] } | s -> s 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 ({ pexp_desc = Pexp_ident { txt = Longident.Ldot ( Lident module_name, value_description.pval_name.txt); loc = Location.none }; pexp_loc = Location.none; pexp_attributes = [] }, []) 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 = ({ txt = "ocaml.deprecated"; loc = Location.none }, PStr [{ pstr_loc = Location.none; pstr_desc = Pstr_eval ({ pexp_desc = Pexp_constant (Pconst_string (warning, None)); pexp_loc = Location.none; pexp_attributes = []; }, [])}]) :: 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 (var, arg, body) -> let module_name : Longident.t = Lapply (module_name, Lident var.txt) in let body = remove_self_aliases_of_module_type ~module_name body in { module_type with pmty_desc = Pmty_functor (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, 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 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 = [ { Location.txt = "ocaml.warning"; loc = Location.none }, Parsetree.PStr [{Parsetree.pstr_desc = Pstr_eval ({ Parsetree.pexp_desc = Pexp_constant (Parsetree.Pconst_string ("-3", None)); pexp_attributes = []; pexp_loc = Location.none }, []); pstr_loc = Location.none }] ]; pmtd_loc = Location.none; } else Pstr_module { pmb_name = { txt = 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 [{ pstr_loc = Location.none; pstr_desc = Pstr_eval ({ pexp_desc = Pexp_apply ({ pexp_desc = Pexp_ident { txt = Lident "exit"; loc = Location.none }; pexp_loc = Location.none; pexp_attributes = [] }, [Nolabel, { pexp_desc = Pexp_constant (Pconst_integer ("0", None)); pexp_loc = Location.none; pexp_attributes = [] }]); pexp_loc = Location.none; pexp_attributes = [] }, [])}]) 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-10/interface_generator/interface_dumper.mli000066400000000000000000000000001350471256400233140ustar00rootroot00000000000000stdcompat-10/interface_generator/interface_generator.ml000066400000000000000000001535131350471256400236570ustar00rootroot00000000000000module 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 (id, payload) (id', payload') = Name.equal id id' 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) = match f, f' with | Otag (l, a, t), Otag (l', a', t') -> l.txt = l'.txt && is_attributes_isomorphic kind a a' && 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_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 && 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 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 Interface_tools.try_close ~close:(fun () -> in_channel |> close_in) @@ fun () -> let buf = in_channel |> Lexing.from_channel in Interface_tools.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 = { ptyp_desc; ptyp_loc = Location.none; ptyp_attributes = [] } 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 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 let root_signature = match lex_file root_module_mli Parse.interface with | root_signature -> root_signature | exception (Sys_error _) -> [] in SignaturesTable.add signatures (version, root_module) root_signature; root_signature in let rec lookup_submodule signature hd tl = let module_type = signature |> Interface_tools.List.find_map @@ fun (signature_item : Parsetree.signature_item) -> match signature_item.psig_desc with | Psig_module module_declaration when module_declaration.pmd_name.txt = hd -> Some module_declaration.pmd_type | _ -> 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) = let ptype_manifest = type_decl.ptype_manifest |> Interface_tools.Option.map @@ fun (ty : Parsetree.core_type) -> match ty.ptyp_desc with | Ptyp_constr ({ txt = Lident "fpclass"; loc }, []) -> let txt = Longident.Ldot (Lident "Pervasives", "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" -> 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 (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 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_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_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, 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 (var, arg, body) -> let arg = Interface_tools.Option.map (compat_module_type ~module_name ~reference_version ~version) arg in let module_name = Longident.Lapply (module_name, Lident var.txt) in let body = compat_module_type ~module_name ~reference_version ~version body in { module_type with pmty_desc = Pmty_functor (var, 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 (x, arg, body), Pmty_functor (x', arg', body') -> Name.equal x x' && Interface_tools.Option.equal (is_module_type_isomorphic kind ~version ~version') arg 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) = Name.equal module_declaration.pmd_name module_declaration'.pmd_name && 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_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_extension_constructor_isomorphic kind ~version extension_constructor ~version' extension_constructor' | Psig_typext type_extension, Psig_typext type_extension' -> true | _ -> failwith "is_signature_item_isomorphic" 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 |> Interface_tools.List.find_map_opt @@ 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 (var, arg, body) -> let arg = arg |> Interface_tools.Option.map @@ fake_module_type ~module_name ~reference_version ~version in let body = fake_module_type ~module_name ~reference_version ~version body in { module_type with pmty_desc = Pmty_functor (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 = match Interface_tools.Option.filter (Type_declaration_block.is_isomorphic Ignore_attributes block) (String.Map.find_opt first_type_name s.types) 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 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, 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 = { ptyp_desc; ptyp_loc = Location.none; ptyp_attributes = [] } 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_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 let psig_desc = Parsetree.Psig_type (rec_flag, [type_decl]) in let result_item = { item with psig_desc } in format_with_without "RESULT_PKG" Pprintast.signature formatter [result_item] [item] | 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 let psig_desc = Parsetree.Psig_type (rec_flag, [type_decl]) in let result_item = { item with psig_desc } in format_with_without "UCHAR_PKG" Pprintast.signature formatter [result_item] [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 | _ -> Format.fprintf formatter "%a" Pprintast.signature [item] 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 -> module_declaration.pmd_name.txt | Psig_modtype module_type_declaration -> module_type_declaration.pmtd_name.txt | Psig_exception extension_constructor -> extension_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 ({ ptyp_desc = Ptyp_constr ({ loc = Location.none; txt = Ldot (module_name, type_decl.ptype_name.txt) }, params); ptyp_loc = Location.none; ptyp_attributes = [] })} | 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, 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 (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 var.txt) in let body = body |> add_self_type_manifest_to_module_type ~module_name in { module_type with pmty_desc = Pmty_functor (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 Pprintast.signature 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 main argv = let arg_list = Array.to_list Sys.argv in let module_name, versions = match arg_list with | _ :: module_name :: versions -> module_name, versions | [] | [_] -> failwith "No argument given" in 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 print_endline "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 Format.std_formatter; print_endline "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 () = if not !Sys.interactive then Sys.argv |> main stdcompat-10/interface_generator/interface_generator.mli000066400000000000000000000000001350471256400240060ustar00rootroot00000000000000stdcompat-10/interface_generator/interface_tools.ml000066400000000000000000000076401350471256400230300ustar00rootroot00000000000000module 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 let try_close f ~close = match f () with | result -> close (); result | exception e -> begin try close () with _ -> () end; e |> raise module Version = struct type t = { major : int; minor : int; patch : int; } 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 { major = String.sub version_line index 1 |> int_of_string; minor = String.sub version_line (index + 2) 2 |> int_of_string; 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 } = if include_patch then Printf.sprintf "%d%s%.2d%s%d" major sep minor sep patch else Printf.sprintf "%d%s%.2d" major sep minor end module Lexing = struct include Lexing let set_filename lexbuf filename = lexbuf.lex_curr_p <- { lexbuf.lex_curr_p with pos_fname = filename } 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 module List = struct include List let rec find_map p l = match l with | [] -> raise Not_found | hd :: tl -> match p hd with | None -> find_map p tl | Some x -> x let rec find_map_opt p l = match l with | [] -> None | hd :: tl -> match p hd with | None -> find_map_opt p tl | result -> result end stdcompat-10/interface_generator/interface_tools.mli000066400000000000000000000036671350471256400232060ustar00rootroot00000000000000module 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 val try_close : (unit -> 'a) -> close:(unit -> unit) -> 'a module Version : sig type t = { major : int; minor : int; patch : int; } 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 module Lexing : sig include module type of (struct include Lexing end) val set_filename : lexbuf -> string -> unit 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 module List : sig include module type of (struct include List end) val find_map : ('a -> 'b option) -> 'a list -> 'b val find_map_opt : ('a -> 'b option) -> 'a list -> 'b option end stdcompat-10/interfaces/000077500000000000000000000000001350471256400154245ustar00rootroot00000000000000stdcompat-10/interfaces/3.07/000077500000000000000000000000001350471256400160135ustar00rootroot00000000000000stdcompat-10/interfaces/3.07/arg.mli000066400000000000000000000014201350471256400172640ustar00rootroot00000000000000type 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-10/interfaces/3.07/array.mli000066400000000000000000000025411350471256400176360ustar00rootroot00000000000000external 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-10/interfaces/3.07/arrayLabels.mli000066400000000000000000000027131350471256400207620ustar00rootroot00000000000000external 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-10/interfaces/3.07/buffer.mli000066400000000000000000000006631350471256400177740ustar00rootroot00000000000000type 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-10/interfaces/3.07/callback.mli000066400000000000000000000001231350471256400202460ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/3.07/char.mli000066400000000000000000000003611350471256400174330ustar00rootroot00000000000000external 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-10/interfaces/3.07/complex.mli000066400000000000000000000006021350471256400201630ustar00rootroot00000000000000type 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-10/interfaces/3.07/digest.mli000066400000000000000000000003741350471256400200010ustar00rootroot00000000000000type 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-10/interfaces/3.07/filename.mli000066400000000000000000000010051350471256400202720ustar00rootroot00000000000000val 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-10/interfaces/3.07/format.mli000066400000000000000000000126721350471256400200160ustar00rootroot00000000000000val 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-10/interfaces/3.07/gc.mli000066400000000000000000000022511350471256400171070ustar00rootroot00000000000000type 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-10/interfaces/3.07/genlex.mli000066400000000000000000000003011350471256400177720ustar00rootroot00000000000000type 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-10/interfaces/3.07/hashtbl.mli000066400000000000000000000031521350471256400201440ustar00rootroot00000000000000type ('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-10/interfaces/3.07/int32.mli000066400000000000000000000023661350471256400174640ustar00rootroot00000000000000val 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-10/interfaces/3.07/int64.mli000066400000000000000000000031521350471256400174630ustar00rootroot00000000000000val 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-10/interfaces/3.07/lazy.mli000066400000000000000000000003041350471256400174720ustar00rootroot00000000000000type '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-10/interfaces/3.07/lexing.mli000066400000000000000000000027231350471256400200100ustar00rootroot00000000000000type 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-10/interfaces/3.07/list.mli000066400000000000000000000036751350471256400175040ustar00rootroot00000000000000val 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-10/interfaces/3.07/listLabels.mli000066400000000000000000000040311350471256400206120ustar00rootroot00000000000000val 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-10/interfaces/3.07/map.mli000066400000000000000000000016631350471256400173010ustar00rootroot00000000000000module 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-10/interfaces/3.07/marshal.mli000066400000000000000000000006701350471256400201500ustar00rootroot00000000000000type 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-10/interfaces/3.07/moreLabels.mli000066400000000000000000000113271350471256400206070ustar00rootroot00000000000000module 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-10/interfaces/3.07/nativeint.mli000066400000000000000000000032411350471256400205170ustar00rootroot00000000000000val 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-10/interfaces/3.07/obj.mli000066400000000000000000000016231350471256400172720ustar00rootroot00000000000000type 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-10/interfaces/3.07/oo.mli000066400000000000000000000002631350471256400171340ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.label val public_method_label : string -> CamlinternalOO.label stdcompat-10/interfaces/3.07/parsing.mli000066400000000000000000000017041350471256400201630ustar00rootroot00000000000000val 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-10/interfaces/3.07/pervasives.mli000066400000000000000000000163561350471256400207200ustar00rootroot00000000000000external 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-10/interfaces/3.07/printexc.mli000066400000000000000000000001441350471256400203510ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-10/interfaces/3.07/printf.mli000066400000000000000000000007501350471256400200220ustar00rootroot00000000000000val 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-10/interfaces/3.07/queue.mli000066400000000000000000000006501350471256400176430ustar00rootroot00000000000000type '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-10/interfaces/3.07/random.mli000066400000000000000000000012701350471256400177760ustar00rootroot00000000000000val 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-10/interfaces/3.07/scanf.mli000066400000000000000000000014251350471256400176120ustar00rootroot00000000000000module 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-10/interfaces/3.07/set.mli000066400000000000000000000032741350471256400173170ustar00rootroot00000000000000module 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-10/interfaces/3.07/sort.mli000066400000000000000000000002471350471256400175100ustar00rootroot00000000000000val 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-10/interfaces/3.07/stack.mli000066400000000000000000000004131350471256400176210ustar00rootroot00000000000000type '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-10/interfaces/3.07/stdLabels.mli000066400000000000000000000116701350471256400204400ustar00rootroot00000000000000module 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-10/interfaces/3.07/stream.mli000066400000000000000000000012611350471256400200110ustar00rootroot00000000000000type '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-10/interfaces/3.07/string.mli000066400000000000000000000025201350471256400200230ustar00rootroot00000000000000external 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-10/interfaces/3.07/stringLabels.mli000066400000000000000000000026001350471256400211450ustar00rootroot00000000000000external 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-10/interfaces/3.07/sys.mli000066400000000000000000000024661350471256400173440ustar00rootroot00000000000000val 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-10/interfaces/3.07/weak.mli000066400000000000000000000024631350471256400174520ustar00rootroot00000000000000type '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-10/interfaces/3.08/000077500000000000000000000000001350471256400160145ustar00rootroot00000000000000stdcompat-10/interfaces/3.08/arg.mli000066400000000000000000000015231350471256400172710ustar00rootroot00000000000000type 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-10/interfaces/3.08/array.mli000066400000000000000000000025531350471256400176420ustar00rootroot00000000000000external 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-10/interfaces/3.08/arrayLabels.mli000066400000000000000000000027251350471256400207660ustar00rootroot00000000000000external 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-10/interfaces/3.08/buffer.mli000066400000000000000000000007621350471256400177750ustar00rootroot00000000000000type 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-10/interfaces/3.08/callback.mli000066400000000000000000000001231350471256400202470ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/3.08/char.mli000066400000000000000000000003611350471256400174340ustar00rootroot00000000000000external 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-10/interfaces/3.08/complex.mli000066400000000000000000000006021350471256400201640ustar00rootroot00000000000000type 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-10/interfaces/3.08/digest.mli000066400000000000000000000004011350471256400177710ustar00rootroot00000000000000type 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-10/interfaces/3.08/filename.mli000066400000000000000000000010051350471256400202730ustar00rootroot00000000000000val 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-10/interfaces/3.08/format.mli000066400000000000000000000131331350471256400200100ustar00rootroot00000000000000val 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-10/interfaces/3.08/gc.mli000066400000000000000000000024651350471256400171170ustar00rootroot00000000000000type 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-10/interfaces/3.08/genlex.mli000066400000000000000000000003011350471256400177730ustar00rootroot00000000000000type 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-10/interfaces/3.08/hashtbl.mli000066400000000000000000000033141350471256400201450ustar00rootroot00000000000000type ('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-10/interfaces/3.08/int32.mli000066400000000000000000000026241350471256400174620ustar00rootroot00000000000000val 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-10/interfaces/3.08/int64.mli000066400000000000000000000032101350471256400174570ustar00rootroot00000000000000val 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-10/interfaces/3.08/lazy.mli000066400000000000000000000003041350471256400174730ustar00rootroot00000000000000type '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-10/interfaces/3.08/lexing.mli000066400000000000000000000027231350471256400200110ustar00rootroot00000000000000type 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-10/interfaces/3.08/list.mli000066400000000000000000000036751350471256400175050ustar00rootroot00000000000000val 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-10/interfaces/3.08/listLabels.mli000066400000000000000000000040311350471256400206130ustar00rootroot00000000000000val 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-10/interfaces/3.08/map.mli000066400000000000000000000023411350471256400172740ustar00rootroot00000000000000module 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-10/interfaces/3.08/marshal.mli000066400000000000000000000006751350471256400201560ustar00rootroot00000000000000type 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-10/interfaces/3.08/moreLabels.mli000066400000000000000000000123411350471256400206050ustar00rootroot00000000000000module 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-10/interfaces/3.08/nativeint.mli000066400000000000000000000032651350471256400205260ustar00rootroot00000000000000val 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-10/interfaces/3.08/obj.mli000066400000000000000000000017351350471256400172770ustar00rootroot00000000000000type 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-10/interfaces/3.08/oo.mli000066400000000000000000000002571350471256400171400ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/3.08/parsing.mli000066400000000000000000000017051350471256400201650ustar00rootroot00000000000000val 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-10/interfaces/3.08/pervasives.mli000066400000000000000000000165261350471256400207200ustar00rootroot00000000000000external 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-10/interfaces/3.08/printexc.mli000066400000000000000000000001441350471256400203520ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-10/interfaces/3.08/printf.mli000066400000000000000000000007501350471256400200230ustar00rootroot00000000000000val 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-10/interfaces/3.08/queue.mli000066400000000000000000000006501350471256400176440ustar00rootroot00000000000000type '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-10/interfaces/3.08/random.mli000066400000000000000000000012701350471256400177770ustar00rootroot00000000000000val 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-10/interfaces/3.08/scanf.mli000066400000000000000000000014251350471256400176130ustar00rootroot00000000000000module 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-10/interfaces/3.08/set.mli000066400000000000000000000034241350471256400173150ustar00rootroot00000000000000module 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-10/interfaces/3.08/sort.mli000066400000000000000000000002471350471256400175110ustar00rootroot00000000000000val 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-10/interfaces/3.08/stack.mli000066400000000000000000000004131350471256400176220ustar00rootroot00000000000000type '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-10/interfaces/3.08/stdLabels.mli000066400000000000000000000123061350471256400204360ustar00rootroot00000000000000module 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-10/interfaces/3.08/stream.mli000066400000000000000000000012611350471256400200120ustar00rootroot00000000000000type '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-10/interfaces/3.08/string.mli000066400000000000000000000025431350471256400200310ustar00rootroot00000000000000external 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-10/interfaces/3.08/stringLabels.mli000066400000000000000000000026731350471256400211600ustar00rootroot00000000000000external 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-10/interfaces/3.08/sys.mli000066400000000000000000000025501350471256400173370ustar00rootroot00000000000000val 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-10/interfaces/3.08/weak.mli000066400000000000000000000024651350471256400174550ustar00rootroot00000000000000type '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-10/interfaces/3.09/000077500000000000000000000000001350471256400160155ustar00rootroot00000000000000stdcompat-10/interfaces/3.09/arg.mli000066400000000000000000000015231350471256400172720ustar00rootroot00000000000000type 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-10/interfaces/3.09/array.mli000066400000000000000000000025531350471256400176430ustar00rootroot00000000000000external 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-10/interfaces/3.09/arrayLabels.mli000066400000000000000000000027251350471256400207670ustar00rootroot00000000000000external 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-10/interfaces/3.09/buffer.mli000066400000000000000000000007621350471256400177760ustar00rootroot00000000000000type 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-10/interfaces/3.09/callback.mli000066400000000000000000000001231350471256400202500ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/3.09/char.mli000066400000000000000000000003611350471256400174350ustar00rootroot00000000000000external 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-10/interfaces/3.09/complex.mli000066400000000000000000000006021350471256400201650ustar00rootroot00000000000000type 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-10/interfaces/3.09/digest.mli000066400000000000000000000004011350471256400177720ustar00rootroot00000000000000type 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-10/interfaces/3.09/filename.mli000066400000000000000000000010401350471256400202730ustar00rootroot00000000000000val 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-10/interfaces/3.09/format.mli000066400000000000000000000131331350471256400200110ustar00rootroot00000000000000val 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-10/interfaces/3.09/gc.mli000066400000000000000000000024651350471256400171200ustar00rootroot00000000000000type 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-10/interfaces/3.09/genlex.mli000066400000000000000000000003011350471256400177740ustar00rootroot00000000000000type 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-10/interfaces/3.09/hashtbl.mli000066400000000000000000000033141350471256400201460ustar00rootroot00000000000000type ('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-10/interfaces/3.09/int32.mli000066400000000000000000000026241350471256400174630ustar00rootroot00000000000000val 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-10/interfaces/3.09/int64.mli000066400000000000000000000032101350471256400174600ustar00rootroot00000000000000val 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-10/interfaces/3.09/lazy.mli000066400000000000000000000003041350471256400174740ustar00rootroot00000000000000type '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-10/interfaces/3.09/lexing.mli000066400000000000000000000027231350471256400200120ustar00rootroot00000000000000type 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-10/interfaces/3.09/list.mli000066400000000000000000000036751350471256400175060ustar00rootroot00000000000000val 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-10/interfaces/3.09/listLabels.mli000066400000000000000000000040311350471256400206140ustar00rootroot00000000000000val 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-10/interfaces/3.09/map.mli000066400000000000000000000023411350471256400172750ustar00rootroot00000000000000module 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-10/interfaces/3.09/marshal.mli000066400000000000000000000006751350471256400201570ustar00rootroot00000000000000type 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-10/interfaces/3.09/moreLabels.mli000066400000000000000000000123411350471256400206060ustar00rootroot00000000000000module 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-10/interfaces/3.09/nativeint.mli000066400000000000000000000032651350471256400205270ustar00rootroot00000000000000val 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-10/interfaces/3.09/obj.mli000066400000000000000000000017351350471256400173000ustar00rootroot00000000000000type 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-10/interfaces/3.09/oo.mli000066400000000000000000000002571350471256400171410ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/3.09/parsing.mli000066400000000000000000000017051350471256400201660ustar00rootroot00000000000000val 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-10/interfaces/3.09/pervasives.mli000066400000000000000000000165261350471256400207210ustar00rootroot00000000000000external 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-10/interfaces/3.09/printexc.mli000066400000000000000000000001441350471256400203530ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-10/interfaces/3.09/printf.mli000066400000000000000000000021231350471256400200200ustar00rootroot00000000000000val 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-10/interfaces/3.09/queue.mli000066400000000000000000000006501350471256400176450ustar00rootroot00000000000000type '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-10/interfaces/3.09/random.mli000066400000000000000000000012701350471256400200000ustar00rootroot00000000000000val 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-10/interfaces/3.09/scanf.mli000066400000000000000000000020031350471256400176050ustar00rootroot00000000000000module 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-10/interfaces/3.09/set.mli000066400000000000000000000034241350471256400173160ustar00rootroot00000000000000module 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-10/interfaces/3.09/sort.mli000066400000000000000000000002471350471256400175120ustar00rootroot00000000000000val 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-10/interfaces/3.09/stack.mli000066400000000000000000000004131350471256400176230ustar00rootroot00000000000000type '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-10/interfaces/3.09/stdLabels.mli000066400000000000000000000123061350471256400204370ustar00rootroot00000000000000module 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-10/interfaces/3.09/stream.mli000066400000000000000000000012611350471256400200130ustar00rootroot00000000000000type '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-10/interfaces/3.09/string.mli000066400000000000000000000025431350471256400200320ustar00rootroot00000000000000external 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-10/interfaces/3.09/stringLabels.mli000066400000000000000000000026731350471256400211610ustar00rootroot00000000000000external 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-10/interfaces/3.09/sys.mli000066400000000000000000000025501350471256400173400ustar00rootroot00000000000000val 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-10/interfaces/3.09/weak.mli000066400000000000000000000024651350471256400174560ustar00rootroot00000000000000type '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-10/interfaces/3.10/000077500000000000000000000000001350471256400160055ustar00rootroot00000000000000stdcompat-10/interfaces/3.10/arg.mli000066400000000000000000000015231350471256400172620ustar00rootroot00000000000000type 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-10/interfaces/3.10/array.mli000066400000000000000000000025531350471256400176330ustar00rootroot00000000000000external 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-10/interfaces/3.10/arrayLabels.mli000066400000000000000000000027251350471256400207570ustar00rootroot00000000000000external 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-10/interfaces/3.10/buffer.mli000066400000000000000000000007621350471256400177660ustar00rootroot00000000000000type 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-10/interfaces/3.10/callback.mli000066400000000000000000000001231350471256400202400ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/3.10/char.mli000066400000000000000000000003611350471256400174250ustar00rootroot00000000000000external 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-10/interfaces/3.10/complex.mli000066400000000000000000000006021350471256400201550ustar00rootroot00000000000000type 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-10/interfaces/3.10/digest.mli000066400000000000000000000004011350471256400177620ustar00rootroot00000000000000type 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-10/interfaces/3.10/filename.mli000066400000000000000000000010401350471256400202630ustar00rootroot00000000000000val 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-10/interfaces/3.10/format.mli000066400000000000000000000132321350471256400200010ustar00rootroot00000000000000val 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-10/interfaces/3.10/gc.mli000066400000000000000000000024651350471256400171100ustar00rootroot00000000000000type 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-10/interfaces/3.10/genlex.mli000066400000000000000000000003011350471256400177640ustar00rootroot00000000000000type 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-10/interfaces/3.10/hashtbl.mli000066400000000000000000000033141350471256400201360ustar00rootroot00000000000000type ('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-10/interfaces/3.10/int32.mli000066400000000000000000000026241350471256400174530ustar00rootroot00000000000000val 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-10/interfaces/3.10/int64.mli000066400000000000000000000032101350471256400174500ustar00rootroot00000000000000val 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-10/interfaces/3.10/lazy.mli000066400000000000000000000003041350471256400174640ustar00rootroot00000000000000type '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-10/interfaces/3.10/lexing.mli000066400000000000000000000027231350471256400200020ustar00rootroot00000000000000type 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-10/interfaces/3.10/list.mli000066400000000000000000000036751350471256400174760ustar00rootroot00000000000000val 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-10/interfaces/3.10/listLabels.mli000066400000000000000000000040311350471256400206040ustar00rootroot00000000000000val 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-10/interfaces/3.10/map.mli000066400000000000000000000023411350471256400172650ustar00rootroot00000000000000module 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-10/interfaces/3.10/marshal.mli000066400000000000000000000006751350471256400201470ustar00rootroot00000000000000type 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-10/interfaces/3.10/moreLabels.mli000066400000000000000000000123411350471256400205760ustar00rootroot00000000000000module 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-10/interfaces/3.10/nativeint.mli000066400000000000000000000032651350471256400205170ustar00rootroot00000000000000val 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-10/interfaces/3.10/obj.mli000066400000000000000000000017351350471256400172700ustar00rootroot00000000000000type 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-10/interfaces/3.10/oo.mli000066400000000000000000000002571350471256400171310ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/3.10/parsing.mli000066400000000000000000000017051350471256400201560ustar00rootroot00000000000000val 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-10/interfaces/3.10/pervasives.mli000066400000000000000000000167131350471256400207070ustar00rootroot00000000000000external 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-10/interfaces/3.10/printexc.mli000066400000000000000000000001441350471256400203430ustar00rootroot00000000000000val to_string : exn -> string val print : ('a -> 'b) -> 'a -> 'b val catch : ('a -> 'b) -> 'a -> 'b stdcompat-10/interfaces/3.10/printf.mli000066400000000000000000000047511350471256400200210ustar00rootroot00000000000000val 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-10/interfaces/3.10/queue.mli000066400000000000000000000006501350471256400176350ustar00rootroot00000000000000type '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-10/interfaces/3.10/random.mli000066400000000000000000000012701350471256400177700ustar00rootroot00000000000000val 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-10/interfaces/3.10/scanf.mli000066400000000000000000000022331350471256400176020ustar00rootroot00000000000000module 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-10/interfaces/3.10/set.mli000066400000000000000000000034241350471256400173060ustar00rootroot00000000000000module 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-10/interfaces/3.10/sort.mli000066400000000000000000000002471350471256400175020ustar00rootroot00000000000000val 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-10/interfaces/3.10/stack.mli000066400000000000000000000004131350471256400176130ustar00rootroot00000000000000type '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-10/interfaces/3.10/stdLabels.mli000066400000000000000000000123061350471256400204270ustar00rootroot00000000000000module 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-10/interfaces/3.10/stream.mli000066400000000000000000000012611350471256400200030ustar00rootroot00000000000000type '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-10/interfaces/3.10/string.mli000066400000000000000000000025431350471256400200220ustar00rootroot00000000000000external 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-10/interfaces/3.10/stringLabels.mli000066400000000000000000000026731350471256400211510ustar00rootroot00000000000000external 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-10/interfaces/3.10/sys.mli000066400000000000000000000026511350471256400173320ustar00rootroot00000000000000val 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-10/interfaces/3.10/weak.mli000066400000000000000000000024651350471256400174460ustar00rootroot00000000000000type '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-10/interfaces/3.11/000077500000000000000000000000001350471256400160065ustar00rootroot00000000000000stdcompat-10/interfaces/3.11/arg.mli000066400000000000000000000015231350471256400172630ustar00rootroot00000000000000type 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-10/interfaces/3.11/array.mli000066400000000000000000000025531350471256400176340ustar00rootroot00000000000000external 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-10/interfaces/3.11/arrayLabels.mli000066400000000000000000000027251350471256400207600ustar00rootroot00000000000000external 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-10/interfaces/3.11/buffer.mli000066400000000000000000000010461350471256400177630ustar00rootroot00000000000000type 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-10/interfaces/3.11/callback.mli000066400000000000000000000001231350471256400202410ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/3.11/char.mli000066400000000000000000000003611350471256400174260ustar00rootroot00000000000000external 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-10/interfaces/3.11/complex.mli000066400000000000000000000006021350471256400201560ustar00rootroot00000000000000type 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-10/interfaces/3.11/digest.mli000066400000000000000000000004011350471256400177630ustar00rootroot00000000000000type 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-10/interfaces/3.11/filename.mli000066400000000000000000000011411350471256400202660ustar00rootroot00000000000000val 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-10/interfaces/3.11/format.mli000066400000000000000000000132321350471256400200020ustar00rootroot00000000000000val 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-10/interfaces/3.11/gc.mli000066400000000000000000000025301350471256400171020ustar00rootroot00000000000000type 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-10/interfaces/3.11/genlex.mli000066400000000000000000000003011350471256400177650ustar00rootroot00000000000000type 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-10/interfaces/3.11/hashtbl.mli000066400000000000000000000033141350471256400201370ustar00rootroot00000000000000type ('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-10/interfaces/3.11/int32.mli000066400000000000000000000026241350471256400174540ustar00rootroot00000000000000val 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-10/interfaces/3.11/int64.mli000066400000000000000000000032101350471256400174510ustar00rootroot00000000000000val 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-10/interfaces/3.11/lazy.mli000066400000000000000000000003311350471256400174650ustar00rootroot00000000000000type '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-10/interfaces/3.11/lexing.mli000066400000000000000000000027611350471256400200050ustar00rootroot00000000000000type 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-10/interfaces/3.11/list.mli000066400000000000000000000036751350471256400174770ustar00rootroot00000000000000val 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-10/interfaces/3.11/listLabels.mli000066400000000000000000000040311350471256400206050ustar00rootroot00000000000000val 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-10/interfaces/3.11/map.mli000066400000000000000000000023411350471256400172660ustar00rootroot00000000000000module 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-10/interfaces/3.11/marshal.mli000066400000000000000000000006751350471256400201500ustar00rootroot00000000000000type 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-10/interfaces/3.11/moreLabels.mli000066400000000000000000000123411350471256400205770ustar00rootroot00000000000000module 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-10/interfaces/3.11/nativeint.mli000066400000000000000000000032651350471256400205200ustar00rootroot00000000000000val 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-10/interfaces/3.11/obj.mli000066400000000000000000000022071350471256400172640ustar00rootroot00000000000000type 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-10/interfaces/3.11/oo.mli000066400000000000000000000002571350471256400171320ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/3.11/parsing.mli000066400000000000000000000017421350471256400201600ustar00rootroot00000000000000val 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-10/interfaces/3.11/pervasives.mli000066400000000000000000000167131350471256400207100ustar00rootroot00000000000000external 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-10/interfaces/3.11/printexc.mli000066400000000000000000000004571350471256400203530ustar00rootroot00000000000000val 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-10/interfaces/3.11/printf.mli000066400000000000000000000047511350471256400200220ustar00rootroot00000000000000val 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-10/interfaces/3.11/queue.mli000066400000000000000000000006501350471256400176360ustar00rootroot00000000000000type '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-10/interfaces/3.11/random.mli000066400000000000000000000012701350471256400177710ustar00rootroot00000000000000val 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-10/interfaces/3.11/scanf.mli000066400000000000000000000022331350471256400176030ustar00rootroot00000000000000module 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-10/interfaces/3.11/set.mli000066400000000000000000000034241350471256400173070ustar00rootroot00000000000000module 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-10/interfaces/3.11/sort.mli000066400000000000000000000002471350471256400175030ustar00rootroot00000000000000val 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-10/interfaces/3.11/stack.mli000066400000000000000000000004131350471256400176140ustar00rootroot00000000000000type '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-10/interfaces/3.11/stdLabels.mli000066400000000000000000000123061350471256400204300ustar00rootroot00000000000000module 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-10/interfaces/3.11/stream.mli000066400000000000000000000012611350471256400200040ustar00rootroot00000000000000type '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-10/interfaces/3.11/string.mli000066400000000000000000000025431350471256400200230ustar00rootroot00000000000000external 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-10/interfaces/3.11/stringLabels.mli000066400000000000000000000026731350471256400211520ustar00rootroot00000000000000external 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-10/interfaces/3.11/sys.mli000066400000000000000000000026511350471256400173330ustar00rootroot00000000000000val 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-10/interfaces/3.11/weak.mli000066400000000000000000000024651350471256400174470ustar00rootroot00000000000000type '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-10/interfaces/3.12/000077500000000000000000000000001350471256400160075ustar00rootroot00000000000000stdcompat-10/interfaces/3.12/arg.mli000066400000000000000000000016251350471256400172670ustar00rootroot00000000000000type 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-10/interfaces/3.12/array.mli000066400000000000000000000025531350471256400176350ustar00rootroot00000000000000external 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-10/interfaces/3.12/arrayLabels.mli000066400000000000000000000027251350471256400207610ustar00rootroot00000000000000external 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-10/interfaces/3.12/buffer.mli000066400000000000000000000010461350471256400177640ustar00rootroot00000000000000type 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-10/interfaces/3.12/callback.mli000066400000000000000000000001231350471256400202420ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/3.12/char.mli000066400000000000000000000003611350471256400174270ustar00rootroot00000000000000external 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-10/interfaces/3.12/complex.mli000066400000000000000000000006021350471256400201570ustar00rootroot00000000000000type 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-10/interfaces/3.12/digest.mli000066400000000000000000000004011350471256400177640ustar00rootroot00000000000000type 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-10/interfaces/3.12/filename.mli000066400000000000000000000011411350471256400202670ustar00rootroot00000000000000val 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-10/interfaces/3.12/format.mli000066400000000000000000000133661350471256400200130ustar00rootroot00000000000000val 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-10/interfaces/3.12/gc.mli000066400000000000000000000025541350471256400171110ustar00rootroot00000000000000type 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-10/interfaces/3.12/genlex.mli000066400000000000000000000003011350471256400177660ustar00rootroot00000000000000type 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-10/interfaces/3.12/hashtbl.mli000066400000000000000000000033141350471256400201400ustar00rootroot00000000000000type ('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-10/interfaces/3.12/int32.mli000066400000000000000000000026241350471256400174550ustar00rootroot00000000000000val 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-10/interfaces/3.12/int64.mli000066400000000000000000000032101350471256400174520ustar00rootroot00000000000000val 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-10/interfaces/3.12/lazy.mli000066400000000000000000000003311350471256400174660ustar00rootroot00000000000000type '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-10/interfaces/3.12/lexing.mli000066400000000000000000000027611350471256400200060ustar00rootroot00000000000000type 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-10/interfaces/3.12/list.mli000066400000000000000000000036751350471256400175000ustar00rootroot00000000000000val 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-10/interfaces/3.12/listLabels.mli000066400000000000000000000040311350471256400206060ustar00rootroot00000000000000val 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-10/interfaces/3.12/map.mli000066400000000000000000000046271350471256400173000ustar00rootroot00000000000000module 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-10/interfaces/3.12/marshal.mli000066400000000000000000000006751350471256400201510ustar00rootroot00000000000000type 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-10/interfaces/3.12/moreLabels.mli000066400000000000000000000147631350471256400206120ustar00rootroot00000000000000module 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-10/interfaces/3.12/nativeint.mli000066400000000000000000000032651350471256400205210ustar00rootroot00000000000000val 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-10/interfaces/3.12/obj.mli000066400000000000000000000022131350471256400172620ustar00rootroot00000000000000type 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-10/interfaces/3.12/oo.mli000066400000000000000000000002571350471256400171330ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/3.12/parsing.mli000066400000000000000000000017421350471256400201610ustar00rootroot00000000000000val 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-10/interfaces/3.12/pervasives.mli000066400000000000000000000172661350471256400207150ustar00rootroot00000000000000external 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-10/interfaces/3.12/printexc.mli000066400000000000000000000004571350471256400203540ustar00rootroot00000000000000val 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-10/interfaces/3.12/printf.mli000066400000000000000000000047511350471256400200230ustar00rootroot00000000000000val 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-10/interfaces/3.12/queue.mli000066400000000000000000000006501350471256400176370ustar00rootroot00000000000000type '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-10/interfaces/3.12/random.mli000066400000000000000000000012701350471256400177720ustar00rootroot00000000000000val 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-10/interfaces/3.12/scanf.mli000066400000000000000000000025571350471256400176150ustar00rootroot00000000000000module 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-10/interfaces/3.12/set.mli000066400000000000000000000034241350471256400173100ustar00rootroot00000000000000module 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-10/interfaces/3.12/sort.mli000066400000000000000000000002471350471256400175040ustar00rootroot00000000000000val 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-10/interfaces/3.12/stack.mli000066400000000000000000000004131350471256400176150ustar00rootroot00000000000000type '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-10/interfaces/3.12/stdLabels.mli000066400000000000000000000123061350471256400204310ustar00rootroot00000000000000module 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-10/interfaces/3.12/stream.mli000066400000000000000000000012611350471256400200050ustar00rootroot00000000000000type '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-10/interfaces/3.12/string.mli000066400000000000000000000025431350471256400200240ustar00rootroot00000000000000external 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-10/interfaces/3.12/stringLabels.mli000066400000000000000000000026731350471256400211530ustar00rootroot00000000000000external 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-10/interfaces/3.12/sys.mli000066400000000000000000000026511350471256400173340ustar00rootroot00000000000000val 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-10/interfaces/3.12/weak.mli000066400000000000000000000024651350471256400174500ustar00rootroot00000000000000type '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-10/interfaces/4.00/000077500000000000000000000000001350471256400160055ustar00rootroot00000000000000stdcompat-10/interfaces/4.00/arg.mli000066400000000000000000000016251350471256400172650ustar00rootroot00000000000000type 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-10/interfaces/4.00/array.mli000066400000000000000000000025531350471256400176330ustar00rootroot00000000000000external 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-10/interfaces/4.00/arrayLabels.mli000066400000000000000000000027251350471256400207570ustar00rootroot00000000000000external 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-10/interfaces/4.00/buffer.mli000066400000000000000000000010461350471256400177620ustar00rootroot00000000000000type 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-10/interfaces/4.00/callback.mli000066400000000000000000000001231350471256400202400ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.00/char.mli000066400000000000000000000003611350471256400174250ustar00rootroot00000000000000external 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-10/interfaces/4.00/complex.mli000066400000000000000000000006021350471256400201550ustar00rootroot00000000000000type 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-10/interfaces/4.00/digest.mli000066400000000000000000000004701350471256400177700ustar00rootroot00000000000000type 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-10/interfaces/4.00/filename.mli000066400000000000000000000012571350471256400202750ustar00rootroot00000000000000val 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-10/interfaces/4.00/format.mli000066400000000000000000000133661350471256400200110ustar00rootroot00000000000000val 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-10/interfaces/4.00/gc.mli000066400000000000000000000025541350471256400171070ustar00rootroot00000000000000type 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-10/interfaces/4.00/genlex.mli000066400000000000000000000003011350471256400177640ustar00rootroot00000000000000type 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-10/interfaces/4.00/hashtbl.mli000066400000000000000000000066371350471256400201510ustar00rootroot00000000000000type ('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-10/interfaces/4.00/int32.mli000066400000000000000000000026241350471256400174530ustar00rootroot00000000000000val 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-10/interfaces/4.00/int64.mli000066400000000000000000000032101350471256400174500ustar00rootroot00000000000000val 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-10/interfaces/4.00/lazy.mli000066400000000000000000000004611350471256400174700ustar00rootroot00000000000000type '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-10/interfaces/4.00/lexing.mli000066400000000000000000000027611350471256400200040ustar00rootroot00000000000000type 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-10/interfaces/4.00/list.mli000066400000000000000000000040431350471256400174640ustar00rootroot00000000000000val 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-10/interfaces/4.00/listLabels.mli000066400000000000000000000042031350471256400206050ustar00rootroot00000000000000val 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-10/interfaces/4.00/map.mli000066400000000000000000000046271350471256400172760ustar00rootroot00000000000000module 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-10/interfaces/4.00/marshal.mli000066400000000000000000000006751350471256400201470ustar00rootroot00000000000000type 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-10/interfaces/4.00/moreLabels.mli000066400000000000000000000203731350471256400206020ustar00rootroot00000000000000module 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-10/interfaces/4.00/nativeint.mli000066400000000000000000000032651350471256400205170ustar00rootroot00000000000000val 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-10/interfaces/4.00/obj.mli000066400000000000000000000022131350471256400172600ustar00rootroot00000000000000type 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-10/interfaces/4.00/oo.mli000066400000000000000000000002571350471256400171310ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.00/parsing.mli000066400000000000000000000017421350471256400201570ustar00rootroot00000000000000val 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-10/interfaces/4.00/pervasives.mli000066400000000000000000000175511350471256400207100ustar00rootroot00000000000000external 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-10/interfaces/4.00/printexc.mli000066400000000000000000000004571350471256400203520ustar00rootroot00000000000000val 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-10/interfaces/4.00/printf.mli000066400000000000000000000047511350471256400200210ustar00rootroot00000000000000val 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-10/interfaces/4.00/queue.mli000066400000000000000000000006501350471256400176350ustar00rootroot00000000000000type '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-10/interfaces/4.00/random.mli000066400000000000000000000012701350471256400177700ustar00rootroot00000000000000val 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-10/interfaces/4.00/scanf.mli000066400000000000000000000026631350471256400176110ustar00rootroot00000000000000module 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-10/interfaces/4.00/set.mli000066400000000000000000000034241350471256400173060ustar00rootroot00000000000000module 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-10/interfaces/4.00/sort.mli000066400000000000000000000002471350471256400175020ustar00rootroot00000000000000val 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-10/interfaces/4.00/stack.mli000066400000000000000000000004131350471256400176130ustar00rootroot00000000000000type '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-10/interfaces/4.00/stdLabels.mli000066400000000000000000000125151350471256400204310ustar00rootroot00000000000000module 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-10/interfaces/4.00/stream.mli000066400000000000000000000012611350471256400200030ustar00rootroot00000000000000type '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-10/interfaces/4.00/string.mli000066400000000000000000000027401350471256400200210ustar00rootroot00000000000000external 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-10/interfaces/4.00/stringLabels.mli000066400000000000000000000030741350471256400211450ustar00rootroot00000000000000external 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-10/interfaces/4.00/sys.mli000066400000000000000000000026771350471256400173420ustar00rootroot00000000000000val 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-10/interfaces/4.00/weak.mli000066400000000000000000000024651350471256400174460ustar00rootroot00000000000000type '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-10/interfaces/4.01/000077500000000000000000000000001350471256400160065ustar00rootroot00000000000000stdcompat-10/interfaces/4.01/arg.mli000066400000000000000000000021641350471256400172650ustar00rootroot00000000000000type 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-10/interfaces/4.01/array.mli000066400000000000000000000025531350471256400176340ustar00rootroot00000000000000external 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-10/interfaces/4.01/arrayLabels.mli000066400000000000000000000027251350471256400207600ustar00rootroot00000000000000external 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-10/interfaces/4.01/buffer.mli000066400000000000000000000010461350471256400177630ustar00rootroot00000000000000type 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-10/interfaces/4.01/callback.mli000066400000000000000000000001231350471256400202410ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.01/char.mli000066400000000000000000000003611350471256400174260ustar00rootroot00000000000000external 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-10/interfaces/4.01/complex.mli000066400000000000000000000006021350471256400201560ustar00rootroot00000000000000type 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-10/interfaces/4.01/digest.mli000066400000000000000000000004701350471256400177710ustar00rootroot00000000000000type 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-10/interfaces/4.01/filename.mli000066400000000000000000000012571350471256400202760ustar00rootroot00000000000000val 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-10/interfaces/4.01/format.mli000066400000000000000000000144031350471256400200030ustar00rootroot00000000000000val 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-10/interfaces/4.01/gc.mli000066400000000000000000000025541350471256400171100ustar00rootroot00000000000000type 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-10/interfaces/4.01/genlex.mli000066400000000000000000000003011350471256400177650ustar00rootroot00000000000000type 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-10/interfaces/4.01/hashtbl.mli000066400000000000000000000066371350471256400201520ustar00rootroot00000000000000type ('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-10/interfaces/4.01/int32.mli000066400000000000000000000026241350471256400174540ustar00rootroot00000000000000val 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-10/interfaces/4.01/int64.mli000066400000000000000000000032101350471256400174510ustar00rootroot00000000000000val 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-10/interfaces/4.01/lazy.mli000066400000000000000000000004611350471256400174710ustar00rootroot00000000000000type '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-10/interfaces/4.01/lexing.mli000066400000000000000000000027611350471256400200050ustar00rootroot00000000000000type 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-10/interfaces/4.01/list.mli000066400000000000000000000040431350471256400174650ustar00rootroot00000000000000val 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-10/interfaces/4.01/listLabels.mli000066400000000000000000000042031350471256400206060ustar00rootroot00000000000000val 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-10/interfaces/4.01/map.mli000066400000000000000000000046271350471256400172770ustar00rootroot00000000000000module 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-10/interfaces/4.01/marshal.mli000066400000000000000000000007141350471256400201420ustar00rootroot00000000000000type 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-10/interfaces/4.01/moreLabels.mli000066400000000000000000000204751350471256400206060ustar00rootroot00000000000000module 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-10/interfaces/4.01/nativeint.mli000066400000000000000000000032651350471256400205200ustar00rootroot00000000000000val 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-10/interfaces/4.01/obj.mli000066400000000000000000000022131350471256400172610ustar00rootroot00000000000000type 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-10/interfaces/4.01/oo.mli000066400000000000000000000002571350471256400171320ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.01/parsing.mli000066400000000000000000000017421350471256400201600ustar00rootroot00000000000000val 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-10/interfaces/4.01/pervasives.mli000066400000000000000000000177201350471256400207070ustar00rootroot00000000000000external 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-10/interfaces/4.01/printexc.mli000066400000000000000000000010161350471256400203430ustar00rootroot00000000000000val 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-10/interfaces/4.01/printf.mli000066400000000000000000000053301350471256400200140ustar00rootroot00000000000000val 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-10/interfaces/4.01/queue.mli000066400000000000000000000006501350471256400176360ustar00rootroot00000000000000type '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-10/interfaces/4.01/random.mli000066400000000000000000000012701350471256400177710ustar00rootroot00000000000000val 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-10/interfaces/4.01/scanf.mli000066400000000000000000000026631350471256400176120ustar00rootroot00000000000000module 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-10/interfaces/4.01/set.mli000066400000000000000000000035221350471256400173060ustar00rootroot00000000000000module 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-10/interfaces/4.01/sort.mli000066400000000000000000000002471350471256400175030ustar00rootroot00000000000000val 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-10/interfaces/4.01/stack.mli000066400000000000000000000004131350471256400176140ustar00rootroot00000000000000type '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-10/interfaces/4.01/stdLabels.mli000066400000000000000000000125151350471256400204320ustar00rootroot00000000000000module 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-10/interfaces/4.01/stream.mli000066400000000000000000000012611350471256400200040ustar00rootroot00000000000000type '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-10/interfaces/4.01/string.mli000066400000000000000000000027401350471256400200220ustar00rootroot00000000000000external 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-10/interfaces/4.01/stringLabels.mli000066400000000000000000000030741350471256400211460ustar00rootroot00000000000000external 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-10/interfaces/4.01/sys.mli000066400000000000000000000027621350471256400173360ustar00rootroot00000000000000val 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-10/interfaces/4.01/weak.mli000066400000000000000000000024651350471256400174470ustar00rootroot00000000000000type '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-10/interfaces/4.02/000077500000000000000000000000001350471256400160075ustar00rootroot00000000000000stdcompat-10/interfaces/4.02/arg.mli000066400000000000000000000021631350471256400172650ustar00rootroot00000000000000type 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-10/interfaces/4.02/array.mli000066400000000000000000000032041350471256400176270ustar00rootroot00000000000000external 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-10/interfaces/4.02/arrayLabels.mli000066400000000000000000000033021350471256400207510ustar00rootroot00000000000000external 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-10/interfaces/4.02/buffer.mli000066400000000000000000000012261350471256400177640ustar00rootroot00000000000000type 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-10/interfaces/4.02/bytes.mli000066400000000000000000000035461350471256400176500ustar00rootroot00000000000000external 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-10/interfaces/4.02/bytesLabels.mli000066400000000000000000000034771350471256400207760ustar00rootroot00000000000000external 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-10/interfaces/4.02/callback.mli000066400000000000000000000001231350471256400202420ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.02/char.mli000066400000000000000000000003611350471256400174270ustar00rootroot00000000000000external 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-10/interfaces/4.02/complex.mli000066400000000000000000000006021350471256400201570ustar00rootroot00000000000000type 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-10/interfaces/4.02/digest.mli000066400000000000000000000005671350471256400200010ustar00rootroot00000000000000type 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-10/interfaces/4.02/filename.mli000066400000000000000000000014101350471256400202660ustar00rootroot00000000000000val 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-10/interfaces/4.02/format.mli000066400000000000000000000162051350471256400200060ustar00rootroot00000000000000val 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-10/interfaces/4.02/gc.mli000066400000000000000000000025541350471256400171110ustar00rootroot00000000000000type 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-10/interfaces/4.02/genlex.mli000066400000000000000000000003011350471256400177660ustar00rootroot00000000000000type 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-10/interfaces/4.02/hashtbl.mli000066400000000000000000000066371350471256400201530ustar00rootroot00000000000000type ('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-10/interfaces/4.02/int32.mli000066400000000000000000000026241350471256400174550ustar00rootroot00000000000000val 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-10/interfaces/4.02/int64.mli000066400000000000000000000032101350471256400174520ustar00rootroot00000000000000val 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-10/interfaces/4.02/lazy.mli000066400000000000000000000010141350471256400174650ustar00rootroot00000000000000type '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-10/interfaces/4.02/lexing.mli000066400000000000000000000027571350471256400200130ustar00rootroot00000000000000type 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-10/interfaces/4.02/list.mli000066400000000000000000000041331350471256400174660ustar00rootroot00000000000000val 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-10/interfaces/4.02/listLabels.mli000066400000000000000000000042031350471256400206070ustar00rootroot00000000000000val 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-10/interfaces/4.02/map.mli000066400000000000000000000046301350471256400172720ustar00rootroot00000000000000module 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-10/interfaces/4.02/marshal.mli000066400000000000000000000011041350471256400201350ustar00rootroot00000000000000type 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-10/interfaces/4.02/moreLabels.mli000066400000000000000000000206021350471256400205770ustar00rootroot00000000000000module 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-10/interfaces/4.02/nativeint.mli000066400000000000000000000032651350471256400205210ustar00rootroot00000000000000val 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-10/interfaces/4.02/obj.mli000066400000000000000000000030301350471256400172600ustar00rootroot00000000000000type 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-10/interfaces/4.02/oo.mli000066400000000000000000000002571350471256400171330ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.02/parsing.mli000066400000000000000000000017421350471256400201610ustar00rootroot00000000000000val 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-10/interfaces/4.02/pervasives.mli000066400000000000000000000216311350471256400207040ustar00rootroot00000000000000external 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-10/interfaces/4.02/printexc.mli000066400000000000000000000023041350471256400203450ustar00rootroot00000000000000val 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-10/interfaces/4.02/printf.mli000066400000000000000000000013601350471256400200140ustar00rootroot00000000000000val 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-10/interfaces/4.02/queue.mli000066400000000000000000000006501350471256400176370ustar00rootroot00000000000000type '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-10/interfaces/4.02/random.mli000066400000000000000000000012701350471256400177720ustar00rootroot00000000000000val 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-10/interfaces/4.02/scanf.mli000066400000000000000000000031551350471256400176100ustar00rootroot00000000000000module 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-10/interfaces/4.02/set.mli000066400000000000000000000036221350471256400173100ustar00rootroot00000000000000module 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-10/interfaces/4.02/sort.mli000066400000000000000000000007321350471256400175030ustar00rootroot00000000000000val 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-10/interfaces/4.02/stack.mli000066400000000000000000000004131350471256400176150ustar00rootroot00000000000000type '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-10/interfaces/4.02/stdLabels.mli000066400000000000000000000167171350471256400204430ustar00rootroot00000000000000module 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-10/interfaces/4.02/stream.mli000066400000000000000000000013201350471256400200010ustar00rootroot00000000000000type '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-10/interfaces/4.02/string.mli000066400000000000000000000042021350471256400200160ustar00rootroot00000000000000external 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-10/interfaces/4.02/stringLabels.mli000066400000000000000000000041671350471256400211530ustar00rootroot00000000000000external 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-10/interfaces/4.02/sys.mli000066400000000000000000000027621350471256400173370ustar00rootroot00000000000000val 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-10/interfaces/4.02/weak.mli000066400000000000000000000024651350471256400174500ustar00rootroot00000000000000type '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-10/interfaces/4.03/000077500000000000000000000000001350471256400160105ustar00rootroot00000000000000stdcompat-10/interfaces/4.03/arg.mli000066400000000000000000000021631350471256400172660ustar00rootroot00000000000000type 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-10/interfaces/4.03/array.mli000066400000000000000000000040441350471256400176330ustar00rootroot00000000000000external 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-10/interfaces/4.03/arrayLabels.mli000066400000000000000000000040671350471256400207630ustar00rootroot00000000000000external 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-10/interfaces/4.03/buffer.mli000066400000000000000000000012261350471256400177650ustar00rootroot00000000000000type 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-10/interfaces/4.03/bytes.mli000066400000000000000000000047151350471256400176500ustar00rootroot00000000000000external 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-10/interfaces/4.03/bytesLabels.mli000066400000000000000000000036071350471256400207720ustar00rootroot00000000000000external 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-10/interfaces/4.03/callback.mli000066400000000000000000000001231350471256400202430ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.03/char.mli000066400000000000000000000007761350471256400174420ustar00rootroot00000000000000external 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-10/interfaces/4.03/complex.mli000066400000000000000000000006021350471256400201600ustar00rootroot00000000000000type 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-10/interfaces/4.03/digest.mli000066400000000000000000000006221350471256400177720ustar00rootroot00000000000000type 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-10/interfaces/4.03/ephemeron.mli000066400000000000000000000237231350471256400205040ustar00rootroot00000000000000module 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-10/interfaces/4.03/filename.mli000066400000000000000000000014341350471256400202750ustar00rootroot00000000000000val 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-10/interfaces/4.03/format.mli000066400000000000000000000203711350471256400200060ustar00rootroot00000000000000val 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-10/interfaces/4.03/gc.mli000066400000000000000000000032451350471256400171100ustar00rootroot00000000000000type 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-10/interfaces/4.03/genlex.mli000066400000000000000000000003011350471256400177670ustar00rootroot00000000000000type 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-10/interfaces/4.03/hashtbl.mli000066400000000000000000000074371350471256400201530ustar00rootroot00000000000000type ('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-10/interfaces/4.03/int32.mli000066400000000000000000000032431350471256400174540ustar00rootroot00000000000000val 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-10/interfaces/4.03/int64.mli000066400000000000000000000036271350471256400174670ustar00rootroot00000000000000val 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-10/interfaces/4.03/lazy.mli000066400000000000000000000010141350471256400174660ustar00rootroot00000000000000type '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-10/interfaces/4.03/lexing.mli000066400000000000000000000027571350471256400200140ustar00rootroot00000000000000type 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-10/interfaces/4.03/list.mli000066400000000000000000000041771350471256400174770ustar00rootroot00000000000000val 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-10/interfaces/4.03/listLabels.mli000066400000000000000000000042771350471256400206230ustar00rootroot00000000000000val 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-10/interfaces/4.03/map.mli000066400000000000000000000050461350471256400172750ustar00rootroot00000000000000module 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-10/interfaces/4.03/marshal.mli000066400000000000000000000011041350471256400201360ustar00rootroot00000000000000type 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-10/interfaces/4.03/moreLabels.mli000066400000000000000000000217341350471256400206070ustar00rootroot00000000000000module 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-10/interfaces/4.03/nativeint.mli000066400000000000000000000035201350471256400205140ustar00rootroot00000000000000val 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-10/interfaces/4.03/obj.mli000066400000000000000000000042041350471256400172650ustar00rootroot00000000000000type 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-10/interfaces/4.03/oo.mli000066400000000000000000000002571350471256400171340ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.03/parsing.mli000066400000000000000000000017421350471256400201620ustar00rootroot00000000000000val 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-10/interfaces/4.03/pervasives.mli000066400000000000000000000235561350471256400207150ustar00rootroot00000000000000external 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-10/interfaces/4.03/printexc.mli000066400000000000000000000023041350471256400203460ustar00rootroot00000000000000val 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-10/interfaces/4.03/printf.mli000066400000000000000000000013221350471256400200130ustar00rootroot00000000000000val 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-10/interfaces/4.03/queue.mli000066400000000000000000000006501350471256400176400ustar00rootroot00000000000000type '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-10/interfaces/4.03/random.mli000066400000000000000000000012701350471256400177730ustar00rootroot00000000000000val 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-10/interfaces/4.03/scanf.mli000066400000000000000000000035541350471256400176140ustar00rootroot00000000000000module 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-10/interfaces/4.03/set.mli000066400000000000000000000036221350471256400173110ustar00rootroot00000000000000module 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-10/interfaces/4.03/sort.mli000066400000000000000000000007321350471256400175040ustar00rootroot00000000000000val 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-10/interfaces/4.03/stack.mli000066400000000000000000000004731350471256400176240ustar00rootroot00000000000000type '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-10/interfaces/4.03/stdLabels.mli000066400000000000000000000176611350471256400204430ustar00rootroot00000000000000module 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-10/interfaces/4.03/stream.mli000066400000000000000000000013201350471256400200020ustar00rootroot00000000000000type '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-10/interfaces/4.03/string.mli000066400000000000000000000053661350471256400200330ustar00rootroot00000000000000external 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-10/interfaces/4.03/stringLabels.mli000066400000000000000000000042751350471256400211540ustar00rootroot00000000000000external 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-10/interfaces/4.03/sys.mli000066400000000000000000000037111350471256400173330ustar00rootroot00000000000000val 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-10/interfaces/4.03/uchar.mli000066400000000000000000000006021350471256400176130ustar00rootroot00000000000000type 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-10/interfaces/4.03/weak.mli000066400000000000000000000024651350471256400174510ustar00rootroot00000000000000type '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-10/interfaces/4.04/000077500000000000000000000000001350471256400160115ustar00rootroot00000000000000stdcompat-10/interfaces/4.04/arg.mli000066400000000000000000000021631350471256400172670ustar00rootroot00000000000000type 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-10/interfaces/4.04/array.mli000066400000000000000000000040441350471256400176340ustar00rootroot00000000000000external 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-10/interfaces/4.04/arrayLabels.mli000066400000000000000000000040671350471256400207640ustar00rootroot00000000000000external 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-10/interfaces/4.04/buffer.mli000066400000000000000000000012261350471256400177660ustar00rootroot00000000000000type 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-10/interfaces/4.04/bytes.mli000066400000000000000000000046011350471256400176430ustar00rootroot00000000000000external 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-10/interfaces/4.04/bytesLabels.mli000066400000000000000000000034731350471256400207740ustar00rootroot00000000000000external 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-10/interfaces/4.04/callback.mli000066400000000000000000000001231350471256400202440ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.04/char.mli000066400000000000000000000007761350471256400174430ustar00rootroot00000000000000external 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-10/interfaces/4.04/complex.mli000066400000000000000000000006021350471256400201610ustar00rootroot00000000000000type 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-10/interfaces/4.04/digest.mli000066400000000000000000000006221350471256400177730ustar00rootroot00000000000000type 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-10/interfaces/4.04/ephemeron.mli000066400000000000000000000237231350471256400205050ustar00rootroot00000000000000module 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-10/interfaces/4.04/filename.mli000066400000000000000000000015451350471256400203010ustar00rootroot00000000000000val 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-10/interfaces/4.04/format.mli000066400000000000000000000204441350471256400200100ustar00rootroot00000000000000val 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-10/interfaces/4.04/gc.mli000066400000000000000000000035221350471256400171070ustar00rootroot00000000000000type 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-10/interfaces/4.04/genlex.mli000066400000000000000000000003011350471256400177700ustar00rootroot00000000000000type 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-10/interfaces/4.04/hashtbl.mli000066400000000000000000000074371350471256400201540ustar00rootroot00000000000000type ('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-10/interfaces/4.04/int32.mli000066400000000000000000000032431350471256400174550ustar00rootroot00000000000000val 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-10/interfaces/4.04/int64.mli000066400000000000000000000036271350471256400174700ustar00rootroot00000000000000val 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-10/interfaces/4.04/lazy.mli000066400000000000000000000010141350471256400174670ustar00rootroot00000000000000type '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-10/interfaces/4.04/lexing.mli000066400000000000000000000027571350471256400200150ustar00rootroot00000000000000type 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-10/interfaces/4.04/list.mli000066400000000000000000000041771350471256400175000ustar00rootroot00000000000000val 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-10/interfaces/4.04/listLabels.mli000066400000000000000000000042771350471256400206240ustar00rootroot00000000000000val 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-10/interfaces/4.04/map.mli000066400000000000000000000050461350471256400172760ustar00rootroot00000000000000module 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-10/interfaces/4.04/marshal.mli000066400000000000000000000011041350471256400201370ustar00rootroot00000000000000type 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-10/interfaces/4.04/moreLabels.mli000066400000000000000000000220561350471256400206060ustar00rootroot00000000000000module 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-10/interfaces/4.04/nativeint.mli000066400000000000000000000035201350471256400205150ustar00rootroot00000000000000val 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-10/interfaces/4.04/obj.mli000066400000000000000000000042521350471256400172710ustar00rootroot00000000000000type 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-10/interfaces/4.04/oo.mli000066400000000000000000000002571350471256400171350ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.04/parsing.mli000066400000000000000000000017421350471256400201630ustar00rootroot00000000000000val 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-10/interfaces/4.04/pervasives.mli000066400000000000000000000235561350471256400207160ustar00rootroot00000000000000external 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-10/interfaces/4.04/printexc.mli000066400000000000000000000024641350471256400203560ustar00rootroot00000000000000val 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-10/interfaces/4.04/printf.mli000066400000000000000000000013221350471256400200140ustar00rootroot00000000000000val 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-10/interfaces/4.04/queue.mli000066400000000000000000000006501350471256400176410ustar00rootroot00000000000000type '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-10/interfaces/4.04/random.mli000066400000000000000000000012701350471256400177740ustar00rootroot00000000000000val 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-10/interfaces/4.04/scanf.mli000066400000000000000000000035541350471256400176150ustar00rootroot00000000000000module 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-10/interfaces/4.04/set.mli000066400000000000000000000037341350471256400173160ustar00rootroot00000000000000module 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-10/interfaces/4.04/sort.mli000066400000000000000000000007321350471256400175050ustar00rootroot00000000000000val 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-10/interfaces/4.04/spacetime.mli000066400000000000000000000004721350471256400204710ustar00rootroot00000000000000module 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-10/interfaces/4.04/stack.mli000066400000000000000000000004731350471256400176250ustar00rootroot00000000000000type '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-10/interfaces/4.04/stdLabels.mli000066400000000000000000000176511350471256400204430ustar00rootroot00000000000000module 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-10/interfaces/4.04/stream.mli000066400000000000000000000013201350471256400200030ustar00rootroot00000000000000type '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-10/interfaces/4.04/string.mli000066400000000000000000000054501350471256400200260ustar00rootroot00000000000000external 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-10/interfaces/4.04/stringLabels.mli000066400000000000000000000042751350471256400211550ustar00rootroot00000000000000external 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-10/interfaces/4.04/sys.mli000066400000000000000000000040541350471256400173350ustar00rootroot00000000000000val 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-10/interfaces/4.04/uchar.mli000066400000000000000000000006021350471256400176140ustar00rootroot00000000000000type 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-10/interfaces/4.04/weak.mli000066400000000000000000000024651350471256400174520ustar00rootroot00000000000000type '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-10/interfaces/4.05/000077500000000000000000000000001350471256400160125ustar00rootroot00000000000000stdcompat-10/interfaces/4.05/arg.mli000066400000000000000000000030341350471256400172660ustar00rootroot00000000000000type 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-10/interfaces/4.05/array.mli000066400000000000000000000040441350471256400176350ustar00rootroot00000000000000external 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-10/interfaces/4.05/arrayLabels.mli000066400000000000000000000042501350471256400207570ustar00rootroot00000000000000external 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-10/interfaces/4.05/buffer.mli000066400000000000000000000012661350471256400177730ustar00rootroot00000000000000type 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-10/interfaces/4.05/bytes.mli000066400000000000000000000051131350471256400176430ustar00rootroot00000000000000external 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-10/interfaces/4.05/bytesLabels.mli000066400000000000000000000053301350471256400207670ustar00rootroot00000000000000external 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-10/interfaces/4.05/callback.mli000066400000000000000000000001231350471256400202450ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.05/char.mli000066400000000000000000000007761350471256400174440ustar00rootroot00000000000000external 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-10/interfaces/4.05/complex.mli000066400000000000000000000006021350471256400201620ustar00rootroot00000000000000type 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-10/interfaces/4.05/digest.mli000066400000000000000000000006221350471256400177740ustar00rootroot00000000000000type 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-10/interfaces/4.05/ephemeron.mli000066400000000000000000000245611350471256400205070ustar00rootroot00000000000000module 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-10/interfaces/4.05/filename.mli000066400000000000000000000015451350471256400203020ustar00rootroot00000000000000val 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-10/interfaces/4.05/format.mli000066400000000000000000000204441350471256400200110ustar00rootroot00000000000000val 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-10/interfaces/4.05/gc.mli000066400000000000000000000034721350471256400171140ustar00rootroot00000000000000type 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-10/interfaces/4.05/genlex.mli000066400000000000000000000003011350471256400177710ustar00rootroot00000000000000type 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-10/interfaces/4.05/hashtbl.mli000066400000000000000000000077741350471256400201610ustar00rootroot00000000000000type ('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-10/interfaces/4.05/int32.mli000066400000000000000000000033161350471256400174570ustar00rootroot00000000000000val 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-10/interfaces/4.05/int64.mli000066400000000000000000000037021350471256400174630ustar00rootroot00000000000000val 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-10/interfaces/4.05/lazy.mli000066400000000000000000000010141350471256400174700ustar00rootroot00000000000000type '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-10/interfaces/4.05/lexing.mli000066400000000000000000000027571350471256400200160ustar00rootroot00000000000000type 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-10/interfaces/4.05/list.mli000066400000000000000000000046401350471256400174740ustar00rootroot00000000000000val 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-10/interfaces/4.05/listLabels.mli000066400000000000000000000050121350471256400206110ustar00rootroot00000000000000val 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-10/interfaces/4.05/map.mli000066400000000000000000000066341350471256400173030ustar00rootroot00000000000000module 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-10/interfaces/4.05/marshal.mli000066400000000000000000000011041350471256400201400ustar00rootroot00000000000000type 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-10/interfaces/4.05/moreLabels.mli000066400000000000000000000257441350471256400206160ustar00rootroot00000000000000module 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-10/interfaces/4.05/nativeint.mli000066400000000000000000000035771350471256400205320ustar00rootroot00000000000000val 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-10/interfaces/4.05/obj.mli000066400000000000000000000042521350471256400172720ustar00rootroot00000000000000type 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-10/interfaces/4.05/oo.mli000066400000000000000000000002571350471256400171360ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.05/parsing.mli000066400000000000000000000017421350471256400201640ustar00rootroot00000000000000val 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-10/interfaces/4.05/pervasives.mli000066400000000000000000000241131350471256400207050ustar00rootroot00000000000000external 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-10/interfaces/4.05/printexc.mli000066400000000000000000000026131350471256400203530ustar00rootroot00000000000000val 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-10/interfaces/4.05/printf.mli000066400000000000000000000013221350471256400200150ustar00rootroot00000000000000val 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-10/interfaces/4.05/queue.mli000066400000000000000000000006501350471256400176420ustar00rootroot00000000000000type '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-10/interfaces/4.05/random.mli000066400000000000000000000012701350471256400177750ustar00rootroot00000000000000val 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-10/interfaces/4.05/scanf.mli000066400000000000000000000035541350471256400176160ustar00rootroot00000000000000module 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-10/interfaces/4.05/set.mli000066400000000000000000000052621350471256400173150ustar00rootroot00000000000000module 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-10/interfaces/4.05/sort.mli000066400000000000000000000007321350471256400175060ustar00rootroot00000000000000val 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-10/interfaces/4.05/spacetime.mli000066400000000000000000000005151350471256400204700ustar00rootroot00000000000000val 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-10/interfaces/4.05/stack.mli000066400000000000000000000004731350471256400176260ustar00rootroot00000000000000type '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-10/interfaces/4.05/stdLabels.mli000066400000000000000000000226471350471256400204450ustar00rootroot00000000000000module 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-10/interfaces/4.05/stream.mli000066400000000000000000000013201350471256400200040ustar00rootroot00000000000000type '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-10/interfaces/4.05/string.mli000066400000000000000000000057661350471256400200410ustar00rootroot00000000000000external 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-10/interfaces/4.05/stringLabels.mli000066400000000000000000000057641350471256400211620ustar00rootroot00000000000000external 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-10/interfaces/4.05/sys.mli000066400000000000000000000041251350471256400173350ustar00rootroot00000000000000val 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-10/interfaces/4.05/uchar.mli000066400000000000000000000005311350471256400176160ustar00rootroot00000000000000type 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-10/interfaces/4.05/weak.mli000066400000000000000000000026151350471256400174500ustar00rootroot00000000000000type '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-10/interfaces/4.06/000077500000000000000000000000001350471256400160135ustar00rootroot00000000000000stdcompat-10/interfaces/4.06/arg.mli000066400000000000000000000030341350471256400172670ustar00rootroot00000000000000type 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-10/interfaces/4.06/array.mli000066400000000000000000000047701350471256400176440ustar00rootroot00000000000000external 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-10/interfaces/4.06/arrayLabels.mli000066400000000000000000000051741350471256400207660ustar00rootroot00000000000000external 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-10/interfaces/4.06/buffer.mli000066400000000000000000000014751350471256400177760ustar00rootroot00000000000000type 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-10/interfaces/4.06/bytes.mli000066400000000000000000000051131350471256400176440ustar00rootroot00000000000000external 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-10/interfaces/4.06/bytesLabels.mli000066400000000000000000000053401350471256400207710ustar00rootroot00000000000000external 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-10/interfaces/4.06/callback.mli000066400000000000000000000001231350471256400202460ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.06/char.mli000066400000000000000000000007761350471256400174450ustar00rootroot00000000000000external 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-10/interfaces/4.06/complex.mli000066400000000000000000000006021350471256400201630ustar00rootroot00000000000000type 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-10/interfaces/4.06/digest.mli000066400000000000000000000006221350471256400177750ustar00rootroot00000000000000type 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-10/interfaces/4.06/ephemeron.mli000066400000000000000000000245611350471256400205100ustar00rootroot00000000000000module 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-10/interfaces/4.06/filename.mli000066400000000000000000000015451350471256400203030ustar00rootroot00000000000000val 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-10/interfaces/4.06/format.mli000066400000000000000000000176711350471256400200220ustar00rootroot00000000000000type 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-10/interfaces/4.06/gc.mli000066400000000000000000000034721350471256400171150ustar00rootroot00000000000000type 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-10/interfaces/4.06/genlex.mli000066400000000000000000000003011350471256400177720ustar00rootroot00000000000000type 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-10/interfaces/4.06/hashtbl.mli000066400000000000000000000077741350471256400201620ustar00rootroot00000000000000type ('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-10/interfaces/4.06/int32.mli000066400000000000000000000033161350471256400174600ustar00rootroot00000000000000val 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-10/interfaces/4.06/int64.mli000066400000000000000000000037021350471256400174640ustar00rootroot00000000000000val 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-10/interfaces/4.06/lazy.mli000066400000000000000000000010141350471256400174710ustar00rootroot00000000000000type '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-10/interfaces/4.06/lexing.mli000066400000000000000000000027571350471256400200170ustar00rootroot00000000000000type 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-10/interfaces/4.06/list.mli000066400000000000000000000047111350471256400174740ustar00rootroot00000000000000val 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-10/interfaces/4.06/listLabels.mli000066400000000000000000000050711350471256400206170ustar00rootroot00000000000000val 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-10/interfaces/4.06/map.mli000066400000000000000000000070361350471256400173010ustar00rootroot00000000000000module 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-10/interfaces/4.06/marshal.mli000066400000000000000000000011041350471256400201410ustar00rootroot00000000000000type 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-10/interfaces/4.06/moreLabels.mli000066400000000000000000000261661350471256400206160ustar00rootroot00000000000000module 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-10/interfaces/4.06/nativeint.mli000066400000000000000000000035771350471256400205330ustar00rootroot00000000000000val 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-10/interfaces/4.06/obj.mli000066400000000000000000000042521350471256400172730ustar00rootroot00000000000000type 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-10/interfaces/4.06/oo.mli000066400000000000000000000002571350471256400171370ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.06/parsing.mli000066400000000000000000000017421350471256400201650ustar00rootroot00000000000000val 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-10/interfaces/4.06/pervasives.mli000066400000000000000000000241131350471256400207060ustar00rootroot00000000000000external 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-10/interfaces/4.06/printexc.mli000066400000000000000000000026131350471256400203540ustar00rootroot00000000000000val 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-10/interfaces/4.06/printf.mli000066400000000000000000000013221350471256400200160ustar00rootroot00000000000000val 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-10/interfaces/4.06/queue.mli000066400000000000000000000006501350471256400176430ustar00rootroot00000000000000type '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-10/interfaces/4.06/random.mli000066400000000000000000000012701350471256400177760ustar00rootroot00000000000000val 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-10/interfaces/4.06/scanf.mli000066400000000000000000000035671350471256400176230ustar00rootroot00000000000000module 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-10/interfaces/4.06/set.mli000066400000000000000000000052621350471256400173160ustar00rootroot00000000000000module 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-10/interfaces/4.06/sort.mli000066400000000000000000000007321350471256400175070ustar00rootroot00000000000000val 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-10/interfaces/4.06/spacetime.mli000066400000000000000000000005151350471256400204710ustar00rootroot00000000000000val 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-10/interfaces/4.06/stack.mli000066400000000000000000000004731350471256400176270ustar00rootroot00000000000000type '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-10/interfaces/4.06/stdLabels.mli000066400000000000000000000237241350471256400204430ustar00rootroot00000000000000module 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-10/interfaces/4.06/stream.mli000066400000000000000000000013201350471256400200050ustar00rootroot00000000000000type '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-10/interfaces/4.06/string.mli000066400000000000000000000057661350471256400200420ustar00rootroot00000000000000external 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-10/interfaces/4.06/stringLabels.mli000066400000000000000000000061041350471256400211500ustar00rootroot00000000000000external 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-10/interfaces/4.06/sys.mli000066400000000000000000000041251350471256400173360ustar00rootroot00000000000000val 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-10/interfaces/4.06/uchar.mli000066400000000000000000000005611350471256400176220ustar00rootroot00000000000000type 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-10/interfaces/4.06/weak.mli000066400000000000000000000026151350471256400174510ustar00rootroot00000000000000type '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-10/interfaces/4.07/000077500000000000000000000000001350471256400160145ustar00rootroot00000000000000stdcompat-10/interfaces/4.07/arg.mli000066400000000000000000000030341350471256400172700ustar00rootroot00000000000000type 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-10/interfaces/4.07/array.mli000066400000000000000000000051471350471256400176440ustar00rootroot00000000000000external 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-10/interfaces/4.07/arrayLabels.mli000066400000000000000000000053531350471256400207660ustar00rootroot00000000000000external 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-10/interfaces/4.07/buffer.mli000066400000000000000000000017031350471256400177710ustar00rootroot00000000000000type 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-10/interfaces/4.07/bytes.mli000066400000000000000000000052531350471256400176520ustar00rootroot00000000000000external 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-10/interfaces/4.07/bytesLabels.mli000066400000000000000000000055001350471256400207700ustar00rootroot00000000000000external 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-10/interfaces/4.07/callback.mli000066400000000000000000000001231350471256400202470ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.07/char.mli000066400000000000000000000007761350471256400174460ustar00rootroot00000000000000external 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-10/interfaces/4.07/complex.mli000066400000000000000000000006021350471256400201640ustar00rootroot00000000000000type 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-10/interfaces/4.07/digest.mli000066400000000000000000000006221350471256400177760ustar00rootroot00000000000000type 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-10/interfaces/4.07/ephemeron.mli000066400000000000000000000315441350471256400205100ustar00rootroot00000000000000module 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-10/interfaces/4.07/filename.mli000066400000000000000000000015451350471256400203040ustar00rootroot00000000000000val 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-10/interfaces/4.07/float.mli000066400000000000000000000075351350471256400176360ustar00rootroot00000000000000external 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-10/interfaces/4.07/format.mli000066400000000000000000000176711350471256400200230ustar00rootroot00000000000000type 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-10/interfaces/4.07/gc.mli000066400000000000000000000034721350471256400171160ustar00rootroot00000000000000type 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-10/interfaces/4.07/genlex.mli000066400000000000000000000003011350471256400177730ustar00rootroot00000000000000type 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-10/interfaces/4.07/hashtbl.mli000066400000000000000000000125161350471256400201510ustar00rootroot00000000000000type ('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-10/interfaces/4.07/int32.mli000066400000000000000000000033161350471256400174610ustar00rootroot00000000000000val 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-10/interfaces/4.07/int64.mli000066400000000000000000000037021350471256400174650ustar00rootroot00000000000000val 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-10/interfaces/4.07/lazy.mli000066400000000000000000000010141350471256400174720ustar00rootroot00000000000000type '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-10/interfaces/4.07/lexing.mli000066400000000000000000000027571350471256400200200ustar00rootroot00000000000000type 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-10/interfaces/4.07/list.mli000066400000000000000000000050131350471256400174710ustar00rootroot00000000000000val 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-10/interfaces/4.07/listLabels.mli000066400000000000000000000051731350471256400206230ustar00rootroot00000000000000val 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-10/interfaces/4.07/map.mli000066400000000000000000000076301350471256400173020ustar00rootroot00000000000000module 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-10/interfaces/4.07/marshal.mli000066400000000000000000000011031350471256400201410ustar00rootroot00000000000000type 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-10/interfaces/4.07/moreLabels.mli000066400000000000000000000324341350471256400206120ustar00rootroot00000000000000module 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-10/interfaces/4.07/nativeint.mli000066400000000000000000000035771350471256400205340ustar00rootroot00000000000000val 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-10/interfaces/4.07/obj.mli000066400000000000000000000042521350471256400172740ustar00rootroot00000000000000type 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-10/interfaces/4.07/oo.mli000066400000000000000000000002571350471256400171400ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.07/parsing.mli000066400000000000000000000017421350471256400201660ustar00rootroot00000000000000val 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-10/interfaces/4.07/pervasives.mli000066400000000000000000000241131350471256400207070ustar00rootroot00000000000000external 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-10/interfaces/4.07/printexc.mli000066400000000000000000000026131350471256400203550ustar00rootroot00000000000000val 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-10/interfaces/4.07/printf.mli000066400000000000000000000013221350471256400200170ustar00rootroot00000000000000val 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-10/interfaces/4.07/queue.mli000066400000000000000000000010131350471256400176360ustar00rootroot00000000000000type '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-10/interfaces/4.07/random.mli000066400000000000000000000012701350471256400177770ustar00rootroot00000000000000val 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-10/interfaces/4.07/scanf.mli000066400000000000000000000035671350471256400176240ustar00rootroot00000000000000module 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-10/interfaces/4.07/seq.mli000066400000000000000000000005761350471256400173170ustar00rootroot00000000000000type '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-10/interfaces/4.07/set.mli000066400000000000000000000057261350471256400173240ustar00rootroot00000000000000module 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-10/interfaces/4.07/sort.mli000066400000000000000000000007321350471256400175100ustar00rootroot00000000000000val 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-10/interfaces/4.07/spacetime.mli000066400000000000000000000005151350471256400204720ustar00rootroot00000000000000val 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-10/interfaces/4.07/stack.mli000066400000000000000000000006361350471256400176310ustar00rootroot00000000000000type '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-10/interfaces/4.07/stdLabels.mli000066400000000000000000000001541350471256400204340ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-10/interfaces/4.07/stream.mli000066400000000000000000000013201350471256400200060ustar00rootroot00000000000000type '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-10/interfaces/4.07/string.mli000066400000000000000000000061261350471256400200320ustar00rootroot00000000000000external 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-10/interfaces/4.07/stringLabels.mli000066400000000000000000000062441350471256400211560ustar00rootroot00000000000000external 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-10/interfaces/4.07/sys.mli000066400000000000000000000041251350471256400173370ustar00rootroot00000000000000val 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-10/interfaces/4.07/uchar.mli000066400000000000000000000005611350471256400176230ustar00rootroot00000000000000type 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-10/interfaces/4.07/weak.mli000066400000000000000000000026151350471256400174520ustar00rootroot00000000000000type '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-10/interfaces/4.08/000077500000000000000000000000001350471256400160155ustar00rootroot00000000000000stdcompat-10/interfaces/4.08/arg.mli000066400000000000000000000030341350471256400172710ustar00rootroot00000000000000type 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-10/interfaces/4.08/array.mli000066400000000000000000000045121350471256400176400ustar00rootroot00000000000000type '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-10/interfaces/4.08/arrayLabels.mli000066400000000000000000000047041350471256400207660ustar00rootroot00000000000000type '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-10/interfaces/4.08/bool.mli000066400000000000000000000004671350471256400174620ustar00rootroot00000000000000type 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-10/interfaces/4.08/buffer.mli000066400000000000000000000027031350471256400177730ustar00rootroot00000000000000type 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-10/interfaces/4.08/bytes.mli000066400000000000000000000070031350471256400176460ustar00rootroot00000000000000external 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-10/interfaces/4.08/bytesLabels.mli000066400000000000000000000072301350471256400207730ustar00rootroot00000000000000external 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-10/interfaces/4.08/callback.mli000066400000000000000000000001231350471256400202500ustar00rootroot00000000000000val register : string -> 'a -> unit val register_exception : string -> exn -> unit stdcompat-10/interfaces/4.08/char.mli000066400000000000000000000005221350471256400174340ustar00rootroot00000000000000external 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-10/interfaces/4.08/complex.mli000066400000000000000000000006021350471256400201650ustar00rootroot00000000000000type 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-10/interfaces/4.08/digest.mli000066400000000000000000000006221350471256400177770ustar00rootroot00000000000000type 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-10/interfaces/4.08/ephemeron.mli000066400000000000000000000315441350471256400205110ustar00rootroot00000000000000module 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-10/interfaces/4.08/filename.mli000066400000000000000000000015131350471256400203000ustar00rootroot00000000000000val 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-10/interfaces/4.08/float.mli000066400000000000000000000172271350471256400176360ustar00rootroot00000000000000val 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-10/interfaces/4.08/format.mli000066400000000000000000000215401350471256400200120ustar00rootroot00000000000000type 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-10/interfaces/4.08/fun.mli000066400000000000000000000003621350471256400173110ustar00rootroot00000000000000external 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-10/interfaces/4.08/gc.mli000066400000000000000000000036211350471256400171130ustar00rootroot00000000000000type 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-10/interfaces/4.08/genlex.mli000066400000000000000000000003011350471256400177740ustar00rootroot00000000000000type 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-10/interfaces/4.08/hashtbl.mli000066400000000000000000000125161350471256400201520ustar00rootroot00000000000000type ('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-10/interfaces/4.08/int32.mli000066400000000000000000000035631350471256400174660ustar00rootroot00000000000000val 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-10/interfaces/4.08/int64.mli000066400000000000000000000041471350471256400174720ustar00rootroot00000000000000val 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-10/interfaces/4.08/lazy.mli000066400000000000000000000004751350471256400175050ustar00rootroot00000000000000type '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-10/interfaces/4.08/lexing.mli000066400000000000000000000031331350471256400200060ustar00rootroot00000000000000type 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-10/interfaces/4.08/list.mli000066400000000000000000000051741350471256400175020ustar00rootroot00000000000000type '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-10/interfaces/4.08/listLabels.mli000066400000000000000000000053561350471256400206270ustar00rootroot00000000000000type '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-10/interfaces/4.08/map.mli000066400000000000000000000076301350471256400173030ustar00rootroot00000000000000module 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-10/interfaces/4.08/marshal.mli000066400000000000000000000011031350471256400201420ustar00rootroot00000000000000type 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-10/interfaces/4.08/moreLabels.mli000066400000000000000000000325441350471256400206150ustar00rootroot00000000000000module 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-10/interfaces/4.08/nativeint.mli000066400000000000000000000041001350471256400205140ustar00rootroot00000000000000val 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-10/interfaces/4.08/obj.mli000066400000000000000000000041701350471256400172740ustar00rootroot00000000000000type 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-10/interfaces/4.08/oo.mli000066400000000000000000000002571350471256400171410ustar00rootroot00000000000000val copy : (< .. > as 'a) -> 'a external id : < .. > -> int = "%field1" val new_method : string -> CamlinternalOO.tag val public_method_label : string -> CamlinternalOO.tag stdcompat-10/interfaces/4.08/option.mli000066400000000000000000000013331350471256400200300ustar00rootroot00000000000000type '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-10/interfaces/4.08/parsing.mli000066400000000000000000000017421350471256400201670ustar00rootroot00000000000000val 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-10/interfaces/4.08/pervasives.mli000066400000000000000000000240071350471256400207120ustar00rootroot00000000000000external 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-10/interfaces/4.08/printexc.mli000066400000000000000000000026351350471256400203620ustar00rootroot00000000000000type 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-10/interfaces/4.08/printf.mli000066400000000000000000000013221350471256400200200ustar00rootroot00000000000000val 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-10/interfaces/4.08/queue.mli000066400000000000000000000011151350471256400176420ustar00rootroot00000000000000type '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-10/interfaces/4.08/random.mli000066400000000000000000000012701350471256400200000ustar00rootroot00000000000000val 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-10/interfaces/4.08/result.mli000066400000000000000000000021341350471256400200360ustar00rootroot00000000000000type ('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-10/interfaces/4.08/scanf.mli000066400000000000000000000031641350471256400176160ustar00rootroot00000000000000module 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-10/interfaces/4.08/seq.mli000066400000000000000000000005761350471256400173200ustar00rootroot00000000000000type '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-10/interfaces/4.08/set.mli000066400000000000000000000060321350471256400173140ustar00rootroot00000000000000module 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-10/interfaces/4.08/spacetime.mli000066400000000000000000000005151350471256400204730ustar00rootroot00000000000000val 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-10/interfaces/4.08/stack.mli000066400000000000000000000007361350471256400176330ustar00rootroot00000000000000type '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-10/interfaces/4.08/stdLabels.mli000066400000000000000000000001541350471256400204350ustar00rootroot00000000000000module Array = ArrayLabels module Bytes = BytesLabels module List = ListLabels module String = StringLabels stdcompat-10/interfaces/4.08/stdlib.mli000066400000000000000000000267641350471256400200200ustar00rootroot00000000000000external 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-10/interfaces/4.08/stream.mli000066400000000000000000000013201350471256400200070ustar00rootroot00000000000000type '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-10/interfaces/4.08/string.mli000066400000000000000000000042271350471256400200330ustar00rootroot00000000000000external 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-10/interfaces/4.08/stringLabels.mli000066400000000000000000000043771350471256400211640ustar00rootroot00000000000000external 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-10/interfaces/4.08/sys.mli000066400000000000000000000041651350471256400173440ustar00rootroot00000000000000val 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-10/interfaces/4.08/uchar.mli000066400000000000000000000005611350471256400176240ustar00rootroot00000000000000type 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-10/interfaces/4.08/weak.mli000066400000000000000000000026151350471256400174530ustar00rootroot00000000000000type '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-10/missing000077500000000000000000000153361350471256400147100ustar00rootroot00000000000000#! /bin/sh # Common wrapper for a few potentially missing GNU programs. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1996-2018 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-10/stdcompat.ml.in000066400000000000000000000001261350471256400162350ustar00rootroot00000000000000include Stdcompat__root module Stdlib = Stdcompat__stdlib include Stdcompat__stdlib stdcompat-10/stdcompat.mli.in000066400000000000000000000003561350471256400164130ustar00rootroot00000000000000type 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-10/stdcompat.opam000066400000000000000000000014501350471256400161550ustar00rootroot00000000000000opam-version: "2.0" maintainer: "Thierry Martinez " authors: "Thierry Martinez " homepage: "https://github.com/thierry-martinez/stdcompat" bug-reports: "https://github.com/thierry-martinez/stdcompat/issues" license: "BSD" dev-repo: "git+https://github.com/thierry-martinez/stdcompat.git" build: [ ["./configure" "--prefix=%{prefix}%"] [make] ] install: [make "install"] remove: [make "uninstall"] depopts: [ "result" "seq" "uchar" "ocamlfind" ] 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." depends: [ "ocaml" {>= "3.07" & < "4.09.0"} ] stdcompat-10/stdcompat__arg.ml.in000066400000000000000000000074131350471256400172330ustar00rootroot00000000000000@BEGIN_FROM_4_05_0@ include Arg @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ exception Help of string exception Bad of string let not_implemented () = failwith "Stdcompat.Arg is not fully implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." type spec = | Unit of (unit -> unit) | Bool of (bool -> unit) | Set of bool ref | Clear of bool ref | String of (string -> unit) | Set_string of string ref | Int of (int -> unit) | Set_int of int ref | Float of (float -> unit) | Set_float of float ref | Tuple of spec list | Symbol of string list * (string -> unit) | Rest of (string -> unit) | 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 | Expand _ -> not_implemented () 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 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 l = expand_list (Arg.align (no_expand_list l)) @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ let align ?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 _ = not_implemented () let parse_dynamic _ = not_implemented () let parse_expand _ = not_implemented () let parse_and_expand_argv_dynamic _ = not_implemented () @END_BEFORE_4_05_0@ stdcompat-10/stdcompat__arg.mli.in000066400000000000000000000000331350471256400173730ustar00rootroot00000000000000include Stdcompat__arg_s.S stdcompat-10/stdcompat__arg_s.mli.in000066400000000000000000000105171350471256400177250ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_05_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) | Expand of (string -> string array) @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_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) | Expand of (string -> string array) @END_BEFORE_4_05_0@ (** @since 4.05.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) | 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-10/stdcompat__array.ml.in000066400000000000000000000046141350471256400176000ustar00rootroot00000000000000include Array @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_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)) exception Iter 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@ stdcompat-10/stdcompat__array.mli.in000066400000000000000000000000351350471256400177420ustar00rootroot00000000000000include Stdcompat__array_s.S stdcompat-10/stdcompat__arrayLabels.ml.in000066400000000000000000000015351350471256400207220ustar00rootroot00000000000000include ArrayLabels @BEGIN_BEFORE_4_03_0@ let create_float = Stdcompat__array.create_float let make_float = create_float let exists ~f a = Stdcompat__array.exists f a let for_all ~f a = Stdcompat__array.for_all f a let mem item ~set = Stdcompat__array.mem item set let memq item ~set = Stdcompat__array.memq item set @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ let iter2 ~f a b = Stdcompat__array.iter2 f a b let map2 ~f a b = Stdcompat__array.map2 f a b @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_06_0@ module Floatarray = Stdcompat__array.Floatarray @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_07_0@ let of_seq g = of_list (Stdcompat__list.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@ type 'a t = 'a array @END_BEFORE_4_08_0@ stdcompat-10/stdcompat__arrayLabels.mli.in000066400000000000000000000000431350471256400210640ustar00rootroot00000000000000include Stdcompat__arrayLabels_s.S stdcompat-10/stdcompat__arrayLabels_s.mli.in000066400000000000000000000171051350471256400214150ustar00rootroot00000000000000module 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 *) @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 *) val exists : f:('a -> bool) -> 'a array -> bool (** @since 4.03.0: val exists : f:('a -> bool) -> 'a array -> bool *) val for_all : f:('a -> bool) -> 'a array -> bool (** @since 4.03.0: val for_all : 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 *) @BEGIN_FROM_4_03_0@ external create_float : int -> float array = "caml_make_float_vect" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val create_float : int -> float array @END_BEFORE_4_03_0@ (** @since 4.03.0: external create_float : int -> float array = "caml_make_float_vect" *) @BEGIN_FROM_4_08_0@ val make_float : int -> float array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val make_float : int -> float array @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val make_float : int -> float array @since 4.03.0: val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] *) external length : 'a array -> int = "%array_length" (** Alias for {!ArrayLabels.length} *) external get : 'a array -> int -> 'a = "%array_safe_get" (** Alias for {!ArrayLabels.get} *) external set : 'a array -> int -> 'a -> unit = "%array_safe_set" (** Alias for {!ArrayLabels.set} *) @BEGIN_FROM_3_08_0@ external make : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external make : int -> 'a -> 'a array = "make_vect" @END_BEFORE_3_08_0@ (** @since 3.08.0: external make : int -> 'a -> 'a array = "caml_make_vect" @since 3.07.0: external make : int -> 'a -> 'a array = "make_vect" *) @BEGIN_FROM_4_08_0@ external create : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external create : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external create : int -> 'a -> 'a array = "make_vect" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external create : int -> 'a -> 'a array = "caml_make_vect" @since 4.02.0: external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] @since 3.08.0: external create : int -> 'a -> 'a array = "caml_make_vect" @since 3.07.0: external create : 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} *) @BEGIN_FROM_4_08_0@ val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array @since 4.02.0: val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] @since 3.07.0: val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array *) 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 map : f:('a -> 'b) -> 'a array -> 'b array (** Alias for {!ArrayLabels.map} *) val iteri : f:(int -> 'a -> unit) -> 'a array -> unit (** Alias for {!ArrayLabels.iteri} *) val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array (** Alias for {!ArrayLabels.mapi} *) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a (** Alias for {!ArrayLabels.fold_left} *) @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@ (** @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-10/stdcompat__array_s.mli.in000066400000000000000000000166461350471256400203030ustar00rootroot00000000000000module 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 *) @BEGIN_FROM_4_07_0@ val to_seq : 'a array -> 'a Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seq : 'a array -> 'a Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seq : 'a array -> 'a Seq.t *) @BEGIN_FROM_4_07_0@ val to_seqi : 'a array -> (int * 'a) Seq.t @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val to_seqi : 'a array -> (int * 'a) Stdcompat__seq.t @END_BEFORE_4_07_0@ (** @since 4.07.0: val to_seqi : 'a array -> (int * 'a) Seq.t *) @BEGIN_FROM_4_07_0@ val of_seq : 'a Seq.t -> 'a array @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ val of_seq : 'a Stdcompat__seq.t -> 'a array @END_BEFORE_4_07_0@ (** @since 4.07.0: val of_seq : 'a Seq.t -> 'a array *) @BEGIN_FROM_4_03_0@ external create_float : int -> float array = "caml_make_float_vect" @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val create_float : int -> float array @END_BEFORE_4_03_0@ (** @since 4.03.0: external create_float : int -> float array = "caml_make_float_vect" *) val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit (** @since 4.03.0: val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit *) val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array (** @since 4.03.0: val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array *) val for_all : ('a -> bool) -> 'a array -> bool (** @since 4.03.0: val for_all : ('a -> bool) -> 'a array -> bool *) val exists : ('a -> bool) -> 'a array -> bool (** @since 4.03.0: val exists : ('a -> bool) -> 'a array -> bool *) val mem : 'a -> 'a array -> bool (** @since 4.03.0: val mem : 'a -> 'a array -> bool *) val memq : 'a -> 'a array -> bool (** @since 4.03.0: val memq : 'a -> 'a array -> bool *) @BEGIN_FROM_4_08_0@ val make_float : int -> float array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ external make_float : int -> float array = "caml_make_float_vect" @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val make_float : int -> float array @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val make_float : int -> float array @since 4.03.0: val make_float : int -> float array[@@ocaml.deprecated "Use Array.create_float instead."] @since 4.02.0: external make_float : int -> float array = "caml_make_float_vect" *) external length : 'a array -> int = "%array_length" (** Alias for {!Array.length} *) external get : 'a array -> int -> 'a = "%array_safe_get" (** Alias for {!Array.get} *) external set : 'a array -> int -> 'a -> unit = "%array_safe_set" (** Alias for {!Array.set} *) @BEGIN_FROM_3_08_0@ external make : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external make : int -> 'a -> 'a array = "make_vect" @END_BEFORE_3_08_0@ (** @since 3.08.0: external make : int -> 'a -> 'a array = "caml_make_vect" @since 3.07.0: external make : int -> 'a -> 'a array = "make_vect" *) @BEGIN_FROM_4_08_0@ external create : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external create : int -> 'a -> 'a array = "caml_make_vect" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external create : int -> 'a -> 'a array = "make_vect" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external create : int -> 'a -> 'a array = "caml_make_vect" @since 4.02.0: external create : int -> 'a -> 'a array = "caml_make_vect"[@@ocaml.deprecated "Use Array.make instead."] @since 3.08.0: external create : int -> 'a -> 'a array = "caml_make_vect" @since 3.07.0: external create : 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} *) @BEGIN_FROM_4_08_0@ val create_matrix : int -> int -> 'a -> 'a array array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val create_matrix : int -> int -> 'a -> 'a array array @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val create_matrix : int -> int -> 'a -> 'a array array @since 4.02.0: val create_matrix : int -> int -> 'a -> 'a array array[@@ocaml.deprecated "Use Array.make_matrix instead."] @since 3.07.0: val create_matrix : int -> int -> 'a -> 'a array array *) 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} *) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a (** Alias for {!Array.fold_left} *) @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@ (** @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-10/stdcompat__bool.ml.in000066400000000000000000000006211350471256400174070ustar00rootroot00000000000000@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@ stdcompat-10/stdcompat__bool.mli.in000066400000000000000000000000341350471256400175560ustar00rootroot00000000000000include Stdcompat__bool_s.S stdcompat-10/stdcompat__bool_s.mli.in000066400000000000000000000032601350471256400201040ustar00rootroot00000000000000module 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 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-10/stdcompat__buffer.ml.in000066400000000000000000000112111350471256400177220ustar00rootroot00000000000000include 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 Stdcompat__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 Stdcompat__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 Stdcompat__sys.big_endian then add_int64_be b v else add_int64_le b v @END_BEFORE_4_08_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-10/stdcompat__buffer.mli.in000066400000000000000000000000361350471256400200760ustar00rootroot00000000000000include Stdcompat__buffer_s.S stdcompat-10/stdcompat__buffer_s.mli.in000066400000000000000000000120321350471256400204170ustar00rootroot00000000000000module 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 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} *) val output_buffer : out_channel -> t -> unit (** Alias for {!Buffer.output_buffer} *) end stdcompat-10/stdcompat__bytes.ml.in000066400000000000000000000176441350471256400176170ustar00rootroot00000000000000@BEGIN_BEFORE_4_02_0@ include Stdcompat__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 @END_BEFORE_4_02_0@ @BEGIN_FROM_4_02_0@ include Bytes @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@ @END_FROM_4_02_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 get_uint16_le b i = if i < 0 || succ i >= length b then index_out_of_bounds (); 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_be b i = if i < 0 || succ i >= length b then index_out_of_bounds (); 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_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 set_uint16_le b i v = if i < 0 || succ i >= length b then index_out_of_bounds (); unsafe_set_uint8 b i v; unsafe_set_uint8 b (succ i) (v lsr 8) let set_uint16_be b i v = if i < 0 || succ i >= length b then index_out_of_bounds (); unsafe_set_uint8 b i (v lsr 8); unsafe_set_uint8 b (succ 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@ stdcompat-10/stdcompat__bytes.mli.in000066400000000000000000000000351350471256400177520ustar00rootroot00000000000000include Stdcompat__bytes_s.S stdcompat-10/stdcompat__bytesLabels.ml.in000066400000000000000000000050561350471256400207340ustar00rootroot00000000000000@BEGIN_FROM_4_02_0@ include BytesLabels @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_06_0@ let sub_string b ~pos ~len = sub_string b pos len @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_05_0@ let uppercase_ascii = uppercase let lowercase_ascii = lowercase let capitalize_ascii = capitalize let uncapitalize_ascii = uncapitalize let equal : t -> t -> bool = ( = ) let rindex_from_opt = Stdcompat__bytes.rindex_from_opt let index_from_opt = Stdcompat__bytes.index_from_opt let rindex_opt = Stdcompat__bytes.rindex_opt let index_opt = Stdcompat__bytes.index_opt @END_BEFORE_4_05_0@ @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ include Stdcompat__stringLabels let empty = "" let of_string = copy let to_string = copy let sub_string = sub let unsafe_of_string s = s let unsafe_to_string s = s @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_05_0@ let extend s ~left ~right = Stdcompat__bytes.extend s left right let blit_string = blit let cat = ( ^ ) @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_08_0@ let get_int8 = Stdcompat__bytes.get_int8 let get_uint8 = Stdcompat__bytes.get_uint8 let get_int16_le = Stdcompat__bytes.get_int16_le let get_int16_be = Stdcompat__bytes.get_int16_be let get_int16_ne = Stdcompat__bytes.get_int16_ne let get_uint16_le = Stdcompat__bytes.get_uint16_le let get_uint16_be = Stdcompat__bytes.get_uint16_be let get_uint16_ne = Stdcompat__bytes.get_uint16_ne let get_int32_le = Stdcompat__bytes.get_int32_le let get_int32_be = Stdcompat__bytes.get_int32_be let get_int32_ne = Stdcompat__bytes.get_int32_ne let get_int64_le = Stdcompat__bytes.get_int64_le let get_int64_be = Stdcompat__bytes.get_int64_be let get_int64_ne = Stdcompat__bytes.get_int64_ne let set_int8 = Stdcompat__bytes.set_int8 let set_uint8 = Stdcompat__bytes.set_uint8 let set_int16_le = Stdcompat__bytes.set_int16_le let set_int16_be = Stdcompat__bytes.set_int16_be let set_int16_ne = Stdcompat__bytes.set_int16_ne let set_uint16_le = Stdcompat__bytes.set_uint16_le let set_uint16_be = Stdcompat__bytes.set_uint16_be let set_uint16_ne = Stdcompat__bytes.set_uint16_ne let set_int32_le = Stdcompat__bytes.set_int32_le let set_int32_be = Stdcompat__bytes.set_int32_be let set_int32_ne = Stdcompat__bytes.set_int32_ne let set_int64_le = Stdcompat__bytes.set_int64_le let set_int64_be = Stdcompat__bytes.set_int64_be let set_int64_ne = Stdcompat__bytes.set_int64_ne @END_BEFORE_4_08_0@ stdcompat-10/stdcompat__bytesLabels.mli.in000066400000000000000000000000431350471256400210740ustar00rootroot00000000000000include Stdcompat__bytesLabels_s.S stdcompat-10/stdcompat__bytesLabels_s.mli.in000066400000000000000000000624631350471256400214340ustar00rootroot00000000000000module 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_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 *) @BEGIN_FROM_4_08_0@ val uppercase : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ @BEGIN_FROM_4_02_0@ val uppercase : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val uppercase : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uppercase : bytes -> bytes @since 4.05.0: val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] @since 4.02.0: val uppercase : bytes -> bytes *) @BEGIN_FROM_4_08_0@ val lowercase : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ @BEGIN_FROM_4_02_0@ val lowercase : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val lowercase : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lowercase : bytes -> bytes @since 4.05.0: val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] @since 4.02.0: val lowercase : bytes -> bytes *) @BEGIN_FROM_4_08_0@ val capitalize : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ @BEGIN_FROM_4_02_0@ val capitalize : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val capitalize : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val capitalize : bytes -> bytes @since 4.05.0: val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] @since 4.02.0: val capitalize : bytes -> bytes *) @BEGIN_FROM_4_08_0@ val uncapitalize : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ @BEGIN_FROM_4_02_0@ val uncapitalize : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val uncapitalize : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uncapitalize : bytes -> bytes @since 4.05.0: val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] @since 4.02.0: val uncapitalize : bytes -> bytes *) val compare : t -> t -> int (** @since 4.02.0: val compare : t -> t -> int *) @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" *) @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 *) end stdcompat-10/stdcompat__bytes_s.mli.in000066400000000000000000000612421350471256400203030ustar00rootroot00000000000000module 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_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 *) @BEGIN_FROM_4_08_0@ val uppercase : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ val uppercase : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val uppercase : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uppercase : bytes -> bytes @since 4.03.0: val uppercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uppercase_ascii instead."] @since 4.02.0: val uppercase : bytes -> bytes *) @BEGIN_FROM_4_08_0@ val lowercase : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ val lowercase : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val lowercase : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lowercase : bytes -> bytes @since 4.03.0: val lowercase : bytes -> bytes[@@ocaml.deprecated "Use Bytes.lowercase_ascii instead."] @since 4.02.0: val lowercase : bytes -> bytes *) @BEGIN_FROM_4_08_0@ val capitalize : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ val capitalize : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val capitalize : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val capitalize : bytes -> bytes @since 4.03.0: val capitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.capitalize_ascii instead."] @since 4.02.0: val capitalize : bytes -> bytes *) @BEGIN_FROM_4_08_0@ val uncapitalize : bytes -> bytes @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_4_02_0@ val uncapitalize : bytes -> bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val uncapitalize : Stdcompat__init.bytes -> Stdcompat__init.bytes @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uncapitalize : bytes -> bytes @since 4.03.0: val uncapitalize : bytes -> bytes[@@ocaml.deprecated "Use Bytes.uncapitalize_ascii instead."] @since 4.02.0: val uncapitalize : bytes -> bytes *) 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-10/stdcompat__char.ml.in000066400000000000000000000002471350471256400173750ustar00rootroot00000000000000include 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@ stdcompat-10/stdcompat__char.mli.in000066400000000000000000000000341350471256400175400ustar00rootroot00000000000000include Stdcompat__char_s.S stdcompat-10/stdcompat__char_s.mli.in000066400000000000000000000033721350471256400200720ustar00rootroot00000000000000module type S = sig type t = char (** Alias for {!Char.t} *) 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} *) @BEGIN_FROM_4_08_0@ val lowercase : char -> char @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val lowercase : char -> char @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lowercase : char -> char @since 4.03.0: val lowercase : char -> char[@@ocaml.deprecated "Use Char.lowercase_ascii instead."] @since 3.07.0: val lowercase : char -> char *) @BEGIN_FROM_4_08_0@ val uppercase : char -> char @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val uppercase : char -> char @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uppercase : char -> char @since 4.03.0: val uppercase : char -> char[@@ocaml.deprecated "Use Char.uppercase_ascii instead."] @since 3.07.0: val uppercase : char -> char *) val compare : t -> t -> int (** Alias for {!Char.compare} *) external unsafe_chr : int -> char = "%identity" (** Alias for {!Char.unsafe_chr} *) end stdcompat-10/stdcompat__digest.ml.in000066400000000000000000000013471350471256400177410ustar00rootroot00000000000000include 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_BEFORE_4_00_0@ let from_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@ stdcompat-10/stdcompat__digest.mli.in000066400000000000000000000000361350471256400201040ustar00rootroot00000000000000include Stdcompat__digest_s.S stdcompat-10/stdcompat__digest_s.mli.in000066400000000000000000000027041350471256400204320ustar00rootroot00000000000000module type S = sig type t = string (** Alias for {!Digest.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_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@ (** @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-10/stdcompat__ephemeron.ml.in000066400000000000000000000425331350471256400204460ustar00rootroot00000000000000@BEGIN_FROM_4_07_0@ include Ephemeron @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 -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__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 -> Stdcompat__hashtbl.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl.statistics end @BEGIN_FROM_4_04_0@ module K1 = struct type ('k, 'd) t = ('k, 'd) Ephemeron.K1.t let create = Ephemeron.K1.create let get_key = Ephemeron.K1.get_key let get_key_copy = Ephemeron.K1.get_key_copy let set_key = Ephemeron.K1.set_key let unset_key = Ephemeron.K1.unset_key let check_key = Ephemeron.K1.check_key let blit_key = Ephemeron.K1.blit_key let get_data = Ephemeron.K1.get_data let get_data_copy = Ephemeron.K1.get_data_copy let set_data = Ephemeron.K1.set_data let unset_data = Ephemeron.K1.unset_data let check_data = Ephemeron.K1.check_data let blit_data = Ephemeron.K1.blit_data module Make (H : Hashtbl.HashedType) = struct include Ephemeron.K1.Make (H) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end module MakeSeeded (H : Hashtbl.SeededHashedType) = struct include Ephemeron.K1.MakeSeeded (H) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end end module K2 = struct type ('k1, 'k2, 'd) t = ('k1, 'k2, 'd) Ephemeron.K2.t let create = Ephemeron.K2.create let get_key1 = Ephemeron.K2.get_key1 let get_key1_copy = Ephemeron.K2.get_key1_copy let set_key1 = Ephemeron.K2.set_key1 let unset_key1 = Ephemeron.K2.unset_key1 let check_key1 = Ephemeron.K2.check_key1 let get_key2 = Ephemeron.K2.get_key2 let get_key2_copy = Ephemeron.K2.get_key2_copy let set_key2 = Ephemeron.K2.set_key2 let unset_key2 = Ephemeron.K2.unset_key2 let check_key2 = Ephemeron.K2.check_key2 let blit_key1 = Ephemeron.K2.blit_key1 let blit_key2 = Ephemeron.K2.blit_key2 let blit_key12 = Ephemeron.K2.blit_key12 let get_data = Ephemeron.K2.get_data let get_data_copy = Ephemeron.K2.get_data_copy let set_data = Ephemeron.K2.set_data let unset_data = Ephemeron.K2.unset_data let check_data = Ephemeron.K2.check_data let blit_data = Ephemeron.K2.blit_data module Make (H1 : Hashtbl.HashedType) (H2 : Hashtbl.HashedType) = struct include Ephemeron.K2.Make (H1) (H2) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end module MakeSeeded (H1 : Hashtbl.SeededHashedType) (H2 : Hashtbl.SeededHashedType) = struct include Ephemeron.K2.MakeSeeded (H1) (H2) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end end module Kn = struct type ('k, 'd) t = ('k, 'd) Ephemeron.Kn.t let create = Ephemeron.Kn.create let get_key = Ephemeron.Kn.get_key let get_key_copy = Ephemeron.Kn.get_key_copy let set_key = Ephemeron.Kn.set_key let unset_key = Ephemeron.Kn.unset_key let check_key = Ephemeron.Kn.check_key let blit_key = Ephemeron.Kn.blit_key let get_data = Ephemeron.Kn.get_data let get_data_copy = Ephemeron.Kn.get_data_copy let set_data = Ephemeron.Kn.set_data let unset_data = Ephemeron.Kn.unset_data let check_data = Ephemeron.Kn.check_data let blit_data = Ephemeron.Kn.blit_data module Make (H : Hashtbl.HashedType) = struct include Ephemeron.Kn.Make (H) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end module MakeSeeded (H : Hashtbl.SeededHashedType) = struct include Ephemeron.Kn.MakeSeeded (H) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end end module GenHashTable = struct type equal = Ephemeron.GenHashTable.equal = | ETrue | EFalse | EDead module MakeSeeded (H : sig type t (** keys *) type 'a container (** contains keys and the associated data *) val hash: int -> t -> int (** same as {!Hashtbl.SeededHashedType} *) val equal: 'a container -> t -> equal (** equality predicate used to compare a key with the one in a container. Can return [EDead] if the keys in the container are dead *) val create: t -> 'a -> 'a container (** [create key data] creates a container from some initials keys and one data *) val get_key: 'a container -> t option (** [get_key cont] returns the keys if they are all alive *) val get_data: 'a container -> 'a option (** [get_data cont] returns the data if it is alive *) val set_key_data: 'a container -> t -> 'a -> unit (** [set_key_data cont] modifies the key and data *) val check_key: 'a container -> bool (** [check_key cont] checks if all the keys contained in the data are alive *) end) = struct include Ephemeron.GenHashTable.MakeSeeded (H) @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 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 @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_05_0@ let find_opt tbl key = Stdcompat__tools.option_find (find tbl) key @END_BEFORE_4_05_0@ end end @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ let not_implemented () = failwith "Stdcompat.Ephemeron is not implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." module K1 =struct type ('k, 'd) t let create _ = not_implemented () let get_key _ = not_implemented () let get_key_copy _ = not_implemented () let set_key _ = not_implemented () let unset_key _ = not_implemented () let check_key _ = not_implemented () let blit_key _ = not_implemented () let get_data _ = not_implemented () let get_data_copy _ = not_implemented () let set_data _ = not_implemented () let unset_data _ = not_implemented () let check_data _ = not_implemented () let blit_data _ = 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 end module K2 = struct type ('k1, 'k2, 'd) t let create _ = not_implemented () let get_key1 _ = not_implemented () let get_key1_copy _ = not_implemented () let set_key1 _ = not_implemented () let unset_key1 _ = not_implemented () let check_key1 _ = not_implemented () let get_key2 _ = not_implemented () let get_key2_copy _ = not_implemented () let set_key2 _ = not_implemented () let unset_key2 _ = not_implemented () let check_key2 _ = not_implemented () let blit_key1 _ = not_implemented () let blit_key2 _ = not_implemented () let blit_key12 _ = not_implemented () let get_data _ = not_implemented () let get_data_copy _ = not_implemented () let set_data _ = not_implemented () let unset_data _ = not_implemented () let check_data _ = not_implemented () let blit_data _ = 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 hash seed (x, y) = Hashtbl.hash (H1.hash seed x, H2.hash seed y) end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end end module Kn = struct type ('k, 'd) t let create _ = not_implemented () let get_key _ = not_implemented () let get_key_copy _ = not_implemented () let set_key _ = not_implemented () let unset_key _ = not_implemented () let check_key _ = not_implemented () let blit_key _ = not_implemented () let get_data _ = not_implemented () let get_data_copy _ = not_implemented () let set_data _ = not_implemented () let unset_data _ = not_implemented () let check_data _ = not_implemented () let blit_data _ = 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 hash seed x = Hashtbl.hash (Array.map (H.hash seed) x) end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end end module GenHashTable = struct type equal = | ETrue | EFalse | EDead module MakeSeeded (H : sig type t (** keys *) type 'a container (** contains keys and the associated data *) val hash: int -> t -> int (** same as {!Hashtbl.SeededHashedType} *) val equal: 'a container -> t -> equal (** equality predicate used to compare a key with the one in a container. Can return [EDead] if the keys in the container are dead *) val create: t -> 'a -> 'a container (** [create key data] creates a container from some initials keys and one data *) val get_key: 'a container -> t option (** [get_key cont] returns the keys if they are all alive *) val get_data: 'a container -> 'a option (** [get_data cont] returns the data if it is alive *) val set_key_data: 'a container -> t -> 'a -> unit (** [set_key_data cont] modifies the key and data *) val check_key: 'a container -> bool (** [check_key cont] checks if all the keys contained in the data are alive *) end) = struct include Stdcompat__hashtbl.MakeSeeded (struct type t = H.t let equal _ _ = false let hash = H.hash end) let clean _ = not_implemented () let stats_alive _ = not_implemented () end end @END_BEFORE_4_04_0@ @END_BEFORE_4_07_0@ stdcompat-10/stdcompat__ephemeron.mli.in000066400000000000000000000000411350471256400206030ustar00rootroot00000000000000include Stdcompat__ephemeron_s.S stdcompat-10/stdcompat__ephemeron_s.mli.in000066400000000000000000000457241350471256400211460ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_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 -> 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_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 -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end @END_BEFORE_4_07_0@ (** @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 -> 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 *) @BEGIN_FROM_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 -> 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_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 -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end @END_BEFORE_4_07_0@ (** @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 -> 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 *) @BEGIN_FROM_4_07_0@ module K1 = Ephemeron.K1 @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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 -> Stdcompat__hashtbl_ext.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 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 iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end end @END_BEFORE_4_07_0@ (** @since 4.07.0: module K1 = Ephemeron.K1 *) @BEGIN_FROM_4_07_0@ module K2 = Ephemeron.K2 @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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 -> Stdcompat__hashtbl_ext.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 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 iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end end @END_BEFORE_4_07_0@ (** @since 4.07.0: module K2 = Ephemeron.K2 *) @BEGIN_FROM_4_07_0@ module Kn = Ephemeron.Kn @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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 -> Stdcompat__hashtbl_ext.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 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 iter : (key -> 'a -> unit) -> 'a t -> unit val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b val length : 'a t -> int val stats : 'a t -> Stdcompat__hashtbl_ext.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end end @END_BEFORE_4_07_0@ (** @since 4.07.0: module Kn = Ephemeron.Kn *) @BEGIN_FROM_4_07_0@ module GenHashTable = Ephemeron.GenHashTable @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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 -> Stdcompat__hashtbl_ext.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 val clean : 'a t -> unit val stats_alive : 'a t -> Stdcompat__hashtbl_ext.statistics end end @END_BEFORE_4_07_0@ (** @since 4.07.0: module GenHashTable = Ephemeron.GenHashTable *) end stdcompat-10/stdcompat__filename.ml.in000066400000000000000000000060561350471256400202440ustar00rootroot00000000000000include 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 let filename_suffix, suffix = if Stdcompat__sys.unix then filename_suffix, suffix else Stdcompat__string.lowercase_ascii filename_suffix, Stdcompat__string.lowercase_ascii suffix in if filename_suffix = suffix then Some (String.sub filename 0 len_base) else None else None @END_BEFORE_4_08_0@ @BEGIN_BEFORE_3_09_0@ let temp_dir_name = match Sys.os_type with | "Win32" -> begin try Sys.getenv "TEMP" with Not_found -> "." end | _ (* "Unix" | "Cygwin" *) -> begin try Sys.getenv "TMPDIR" with Not_found -> "/tmp" end @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_4_03_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 open_temp_file ?(mode = [Open_text]) ?(perms = 0o600) ?(temp_dir = get_temp_dir_name ()) prefix suffix = let rec try_name counter = let name = temp_file_name temp_dir prefix suffix in try name, open_out_gen (Open_wronly :: Open_creat :: Open_excl :: mode) perms name with Sys_error _ as e -> if counter >= 1000 then raise e else try_name (succ counter) in try_name 0 @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_3_11_0@ let dir_sep = match Sys.os_type with | "Win32" -> "\\" | _ (* "Unix" | "Cygwin" *) -> "/" @END_BEFORE_3_11_0@ @BEGIN_BEFORE_4_04_0@ let is_dir_sep c s i = if dir_sep.[0] <> c then false else let l = String.length dir_sep in if l = 1 then true else if i + l <= String.length s then String.sub s i l = dir_sep else false 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 s i 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@ stdcompat-10/stdcompat__filename.mli.in000066400000000000000000000000401350471256400204000ustar00rootroot00000000000000include Stdcompat__filename_s.S stdcompat-10/stdcompat__filename_s.mli.in000066400000000000000000000046741350471256400207430ustar00rootroot00000000000000module type S = sig 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 *) @BEGIN_FROM_4_08_0@ val temp_dir_name : string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val temp_dir_name : string @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val temp_dir_name : string @since 4.02.0: val temp_dir_name : string[@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"] @since 3.09.0: val temp_dir_name : 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-10/stdcompat__float.ml.in000066400000000000000000000615521350471256400175730ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Float @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ module Array = struct 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 @BEGIN_FROM_4_07_0@ include (Float : module type of Float with module Array := Array) @END_FROM_4_07_0@ @END_BEFORE_4_08_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 (** @since 4.07.0: type t = float *) let infinity = Pervasives.infinity (** @since 4.07.0: val infinity : float *) let neg_infinity = Pervasives.neg_infinity (** @since 4.07.0: val neg_infinity : float *) let nan = Pervasives.nan (** @since 4.07.0: val nan : float *) @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@ (** @since 4.07.0: val pi : float *) let max_float = Pervasives.max_float (** @since 4.07.0: val max_float : float *) let min_float = Pervasives.min_float (** @since 4.07.0: val min_float : float *) let epsilon = Pervasives.epsilon_float (** @since 4.07.0: val epsilon : float *) let of_string_opt = Stdcompat__pervasives.float_of_string_opt (** @since 4.07.0: val of_string_opt : string -> float option *) let to_string = Pervasives.string_of_float (** @since 4.07.0: val to_string : float -> string *) external compare : float -> float -> int = "%compare" (** @since 4.07.0: val compare : t -> t -> int *) let equal x y = compare x y = 0 (** @since 4.07.0: val equal : t -> t -> bool *) let hash = Hashtbl.hash (** @since 4.07.0: val hash : t -> int *) @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@ (** @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 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@ (** @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@ let log1p = Stdcompat__pervasives.log1p @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 neg : float -> float = "%negfloat" (** Alias for {!Float.neg} *) external add : float -> float -> float = "%addfloat" (** Alias for {!Float.add} *) external sub : float -> float -> float = "%subfloat" (** Alias for {!Float.sub} *) external mul : float -> float -> float = "%mulfloat" (** Alias for {!Float.mul} *) external div : float -> float -> float = "%divfloat" (** Alias for {!Float.div} *) @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.03.0: external rem : float -> float -> float = "caml_fmod_float" "fmod" [@@unboxed ][@@noalloc ] @since 3.11.0: external rem : float -> float -> float = "caml_fmod_float" "fmod" "float" *) external abs : float -> float = "%absfloat" (** Alias for {!Float.abs} *) external of_int : int -> float = "%floatofint" (** Alias for {!Float.of_int} *) external to_int : float -> int = "%intoffloat" (** Alias for {!Float.to_int} *) @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@ (** Alias for {!Float.of_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.03.0: external classify_float : ((float)[@unboxed ]) -> fpclass = "caml_classify_float" "caml_classify_float_unboxed"[@@noalloc ] @since 3.11.0: external classify_float : float -> fpclass = "caml_classify_float" *) @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.03.0: external pow : float -> float -> float = "caml_power_float" "pow" [@@unboxed ][@@noalloc ] @since 3.11.0: external pow : float -> float -> float = "caml_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.11.0: external sqrt : float -> float = "caml_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.11.0: external exp : float -> float = "caml_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.11.0: external log : float -> float = "caml_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.11.0: external log10 : float -> float = "caml_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.11.0: external cos : float -> float = "caml_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.11.0: external sin : float -> float = "caml_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.11.0: external tan : float -> float = "caml_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.11.0: external acos : float -> float = "caml_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.11.0: external asin : float -> float = "caml_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.11.0: external atan : float -> float = "caml_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.11.0: external atan2 : float -> float -> float = "caml_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.11.0: external cosh : float -> float = "caml_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.11.0: external sinh : float -> float = "caml_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.11.0: external tanh : float -> float = "caml_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.11.0: external ceil : float -> float = "caml_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.11.0: external floor : float -> float = "caml_floor_float" "floor" "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@ (** Alias for {!Float.frexp} *) @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.11.0: external ldexp : float -> int -> float = "caml_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@ (** Alias for {!Float.modf} *) @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. module ArrayLabels = struct include 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 @END_BEFORE_4_08_0@ stdcompat-10/stdcompat__float.mli.in000066400000000000000000000000351350471256400177310ustar00rootroot00000000000000include Stdcompat__float_s.S stdcompat-10/stdcompat__float_s.mli.in000066400000000000000000000625371350471256400202720ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_07_0@ type fpclass = Pervasives.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 = Pervasives.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_4_08_0@ module Array = Float.Array @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_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 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 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 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 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_4_08_0@ (** @since 4.08.0: module Array = Float.Array *) @BEGIN_FROM_4_08_0@ module ArrayLabels = Float.ArrayLabels @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_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 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 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 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 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_4_08_0@ (** @since 4.08.0: module ArrayLabels = Float.ArrayLabels *) 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-10/stdcompat__format.ml.in000066400000000000000000000104571350471256400177540ustar00rootroot00000000000000include Format @BEGIN_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 } @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_safe_set_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_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." let asprintf _ = failwith "Not implemented." @END_BEFORE_4_01_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@ stdcompat-10/stdcompat__format.mli.in000066400000000000000000000000361350471256400201150ustar00rootroot00000000000000include Stdcompat__format_s.S stdcompat-10/stdcompat__format_s.mli.in000066400000000000000000001000361350471256400204400ustar00rootroot00000000000000module 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@ type stag = Format.stag = .. @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_01_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 ; @BEGIN_FROM_4_06_0@ out_indent: int -> unit @END_FROM_4_06_0@} @END_FROM_4_01_0@ @BEGIN_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 } @END_BEFORE_4_01_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 *) type formatter_tag_functions = Format.formatter_tag_functions = { mark_open_tag: tag -> string ; mark_close_tag: tag -> string ; print_open_tag: tag -> unit ; print_close_tag: tag -> unit } (** Alias for {!Format.formatter_tag_functions} *) 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 pp_open_tag : formatter -> tag -> unit (** @since 4.08.0: val pp_open_tag : formatter -> tag -> unit *) val formatter_of_out_functions : formatter_out_functions -> formatter (** @since 4.06.0: val formatter_of_out_functions : formatter_out_functions -> formatter *) val make_symbolic_output_buffer : unit -> symbolic_output_buffer (** @since 4.06.0: val make_symbolic_output_buffer : unit -> symbolic_output_buffer *) val clear_symbolic_output_buffer : symbolic_output_buffer -> unit (** @since 4.06.0: val clear_symbolic_output_buffer : symbolic_output_buffer -> unit *) val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list (** @since 4.06.0: val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list *) val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list (** @since 4.06.0: val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list *) val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit (** @since 4.06.0: val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit *) val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter (** @since 4.06.0: val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter *) val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 4.03.0: val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b *) val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit (** @since 4.02.0: val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit *) val pp_print_text : formatter -> string -> unit (** @since 4.02.0: val pp_print_text : formatter -> string -> unit *) val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit (** @since 4.01.0: val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit *) val set_formatter_out_functions : formatter_out_functions -> unit (** @since 4.01.0: val set_formatter_out_functions : formatter_out_functions -> unit *) val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions (** @since 4.01.0: val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions *) val get_formatter_out_functions : unit -> formatter_out_functions (** @since 4.01.0: val get_formatter_out_functions : unit -> formatter_out_functions *) val asprintf : ('a, formatter, unit, string) format4 -> 'a (** @since 4.01.0: val asprintf : ('a, formatter, unit, string) format4 -> 'a *) val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 3.12.0: val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b *) val ifprintf : formatter -> ('a, formatter, unit) format -> 'a (** @since 3.10.0: val ifprintf : formatter -> ('a, formatter, unit) format -> 'a *) val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b (** @since 3.08.0: val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) format4 -> 'b *) val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b (** @since 3.08.0: val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b *) val pp_open_box : formatter -> int -> unit (** Alias for {!Format.pp_open_box} *) val open_box : int -> unit (** Alias for {!Format.open_box} *) val pp_close_box : formatter -> unit -> unit (** Alias for {!Format.pp_close_box} *) val close_box : unit -> unit (** Alias for {!Format.close_box} *) val pp_open_hbox : formatter -> unit -> unit (** Alias for {!Format.pp_open_hbox} *) val open_hbox : unit -> unit (** Alias for {!Format.open_hbox} *) val pp_open_vbox : formatter -> int -> unit (** Alias for {!Format.pp_open_vbox} *) val open_vbox : int -> unit (** Alias for {!Format.open_vbox} *) val pp_open_hvbox : formatter -> int -> unit (** Alias for {!Format.pp_open_hvbox} *) val open_hvbox : int -> unit (** Alias for {!Format.open_hvbox} *) val pp_open_hovbox : formatter -> int -> unit (** Alias for {!Format.pp_open_hovbox} *) val open_hovbox : int -> unit (** Alias for {!Format.open_hovbox} *) val pp_print_string : formatter -> string -> unit (** Alias for {!Format.pp_print_string} *) val print_string : string -> unit (** Alias for {!Format.print_string} *) val pp_print_as : formatter -> int -> string -> unit (** Alias for {!Format.pp_print_as} *) val print_as : int -> string -> unit (** Alias for {!Format.print_as} *) val pp_print_int : formatter -> int -> unit (** Alias for {!Format.pp_print_int} *) val print_int : int -> unit (** Alias for {!Format.print_int} *) val pp_print_float : formatter -> float -> unit (** Alias for {!Format.pp_print_float} *) val print_float : float -> unit (** Alias for {!Format.print_float} *) val pp_print_char : formatter -> char -> unit (** Alias for {!Format.pp_print_char} *) val print_char : char -> unit (** Alias for {!Format.print_char} *) val pp_print_bool : formatter -> bool -> unit (** Alias for {!Format.pp_print_bool} *) val print_bool : bool -> unit (** Alias for {!Format.print_bool} *) val pp_print_space : formatter -> unit -> unit (** Alias for {!Format.pp_print_space} *) val print_space : unit -> unit (** Alias for {!Format.print_space} *) val pp_print_cut : formatter -> unit -> unit (** Alias for {!Format.pp_print_cut} *) val print_cut : unit -> unit (** Alias for {!Format.print_cut} *) val pp_print_break : formatter -> int -> int -> unit (** Alias for {!Format.pp_print_break} *) val print_break : int -> int -> unit (** Alias for {!Format.print_break} *) val pp_force_newline : formatter -> unit -> unit (** Alias for {!Format.pp_force_newline} *) val force_newline : unit -> unit (** Alias for {!Format.force_newline} *) val pp_print_if_newline : formatter -> unit -> unit (** Alias for {!Format.pp_print_if_newline} *) val print_if_newline : unit -> unit (** Alias for {!Format.print_if_newline} *) val pp_print_flush : formatter -> unit -> unit (** Alias for {!Format.pp_print_flush} *) val print_flush : unit -> unit (** Alias for {!Format.print_flush} *) val pp_print_newline : formatter -> unit -> unit (** Alias for {!Format.pp_print_newline} *) val print_newline : unit -> unit (** Alias for {!Format.print_newline} *) val pp_set_margin : formatter -> int -> unit (** Alias for {!Format.pp_set_margin} *) val set_margin : int -> unit (** Alias for {!Format.set_margin} *) val pp_get_margin : formatter -> unit -> int (** Alias for {!Format.pp_get_margin} *) val get_margin : unit -> int (** Alias for {!Format.get_margin} *) val pp_set_max_indent : formatter -> int -> unit (** Alias for {!Format.pp_set_max_indent} *) val set_max_indent : int -> unit (** Alias for {!Format.set_max_indent} *) val pp_get_max_indent : formatter -> unit -> int (** Alias for {!Format.pp_get_max_indent} *) val get_max_indent : unit -> int (** Alias for {!Format.get_max_indent} *) val pp_set_max_boxes : formatter -> int -> unit (** Alias for {!Format.pp_set_max_boxes} *) val set_max_boxes : int -> unit (** Alias for {!Format.set_max_boxes} *) val pp_get_max_boxes : formatter -> unit -> int (** Alias for {!Format.pp_get_max_boxes} *) val get_max_boxes : unit -> int (** Alias for {!Format.get_max_boxes} *) val pp_over_max_boxes : formatter -> unit -> bool (** Alias for {!Format.pp_over_max_boxes} *) val over_max_boxes : unit -> bool (** Alias for {!Format.over_max_boxes} *) @BEGIN_FROM_4_06_0@ val pp_open_tbox : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_open_tbox : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_open_tbox : formatter -> unit -> unit @since 4.03.0: val pp_open_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_open_tbox : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val open_tbox : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val open_tbox : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val open_tbox : unit -> unit @since 4.03.0: val open_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val open_tbox : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_close_tbox : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_close_tbox : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_close_tbox : formatter -> unit -> unit @since 4.03.0: val pp_close_tbox : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_close_tbox : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val close_tbox : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val close_tbox : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val close_tbox : unit -> unit @since 4.03.0: val close_tbox : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val close_tbox : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_set_tab : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_set_tab : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_set_tab : formatter -> unit -> unit @since 4.03.0: val pp_set_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_set_tab : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val set_tab : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val set_tab : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val set_tab : unit -> unit @since 4.03.0: val set_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val set_tab : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_print_tab : formatter -> unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_print_tab : formatter -> unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_print_tab : formatter -> unit -> unit @since 4.03.0: val pp_print_tab : formatter -> unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_print_tab : formatter -> unit -> unit *) @BEGIN_FROM_4_06_0@ val print_tab : unit -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val print_tab : unit -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val print_tab : unit -> unit @since 4.03.0: val print_tab : unit -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val print_tab : unit -> unit *) @BEGIN_FROM_4_06_0@ val pp_print_tbreak : formatter -> int -> int -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val pp_print_tbreak : formatter -> int -> int -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val pp_print_tbreak : formatter -> int -> int -> unit @since 4.03.0: val pp_print_tbreak : formatter -> int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val pp_print_tbreak : formatter -> int -> int -> unit *) @BEGIN_FROM_4_06_0@ val print_tbreak : int -> int -> unit @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ @BEGIN_FROM_4_03_0@ val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val print_tbreak : int -> int -> unit @END_BEFORE_4_03_0@ @END_BEFORE_4_06_0@ (** @since 4.06.0: val print_tbreak : int -> int -> unit @since 4.03.0: val print_tbreak : int -> int -> unit[@@ocaml.deprecated "Tabulation boxes are not supported any more."] @since 3.07.0: val print_tbreak : int -> int -> unit *) val pp_set_ellipsis_text : formatter -> string -> unit (** Alias for {!Format.pp_set_ellipsis_text} *) val set_ellipsis_text : string -> unit (** Alias for {!Format.set_ellipsis_text} *) val pp_get_ellipsis_text : formatter -> unit -> string (** Alias for {!Format.pp_get_ellipsis_text} *) val get_ellipsis_text : unit -> string (** Alias for {!Format.get_ellipsis_text} *) val pp_set_tags : formatter -> bool -> unit (** Alias for {!Format.pp_set_tags} *) val set_tags : bool -> unit (** Alias for {!Format.set_tags} *) val pp_set_print_tags : formatter -> bool -> unit (** Alias for {!Format.pp_set_print_tags} *) val set_print_tags : bool -> unit (** Alias for {!Format.set_print_tags} *) val pp_set_mark_tags : formatter -> bool -> unit (** Alias for {!Format.pp_set_mark_tags} *) val set_mark_tags : bool -> unit (** Alias for {!Format.set_mark_tags} *) val pp_get_print_tags : formatter -> unit -> bool (** Alias for {!Format.pp_get_print_tags} *) val get_print_tags : unit -> bool (** Alias for {!Format.get_print_tags} *) val pp_get_mark_tags : formatter -> unit -> bool (** Alias for {!Format.pp_get_mark_tags} *) val get_mark_tags : unit -> bool (** Alias for {!Format.get_mark_tags} *) val pp_set_formatter_out_channel : formatter -> out_channel -> unit (** Alias for {!Format.pp_set_formatter_out_channel} *) val set_formatter_out_channel : out_channel -> unit (** Alias for {!Format.set_formatter_out_channel} *) val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit (** Alias for {!Format.pp_set_formatter_output_functions} *) val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit (** Alias for {!Format.set_formatter_output_functions} *) val pp_get_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit)) (** Alias for {!Format.pp_get_formatter_output_functions} *) val get_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit)) (** Alias for {!Format.get_formatter_output_functions} *) val formatter_of_out_channel : out_channel -> formatter (** Alias for {!Format.formatter_of_out_channel} *) val std_formatter : formatter (** Alias for {!Format.std_formatter} *) val err_formatter : formatter (** Alias for {!Format.err_formatter} *) val formatter_of_buffer : Buffer.t -> formatter (** Alias for {!Format.formatter_of_buffer} *) val stdbuf : Buffer.t (** Alias for {!Format.stdbuf} *) val str_formatter : formatter (** Alias for {!Format.str_formatter} *) val flush_str_formatter : unit -> string (** Alias for {!Format.flush_str_formatter} *) val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter (** Alias for {!Format.make_formatter} *) val fprintf : formatter -> ('a, formatter, unit) format -> 'a (** Alias for {!Format.fprintf} *) val printf : ('a, formatter, unit) format -> 'a (** Alias for {!Format.printf} *) val eprintf : ('a, formatter, unit) format -> 'a (** Alias for {!Format.eprintf} *) val sprintf : ('a, unit, string) format -> 'a (** Alias for {!Format.sprintf} *) @BEGIN_FROM_4_08_0@ val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a @since 4.02.0: val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a[@@ocaml.deprecated "- : Buffer.t -> ('a, Format.formatter, unit) format -> 'a = "] @since 3.07.0: val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a *) @BEGIN_FROM_4_08_0@ val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b @since 4.02.0: val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b[@@ocaml.deprecated "Use Format.ksprintf instead."] @since 3.07.0: val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b *) @BEGIN_FROM_4_08_0@ val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ 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."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit @since 4.02.0: 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."] @since 3.07.0: val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit *) @BEGIN_FROM_4_08_0@ val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ 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."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) @since 4.02.0: 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."] @since 3.07.0: val get_all_formatter_output_functions : unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) *) @BEGIN_FROM_4_08_0@ val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ 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."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit @since 4.02.0: 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."] @since 3.07.0: val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit *) @BEGIN_FROM_4_08_0@ val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ 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."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) @since 4.02.0: 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."] @since 3.07.0: val pp_get_all_formatter_output_functions : formatter -> unit -> ((string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)) *) val open_tag : tag -> unit (** Alias for {!Format.open_tag} *) val pp_close_tag : formatter -> unit -> unit (** Alias for {!Format.pp_close_tag} *) val close_tag : unit -> unit (** Alias for {!Format.close_tag} *) val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit (** Alias for {!Format.pp_set_formatter_tag_functions} *) val set_formatter_tag_functions : formatter_tag_functions -> unit (** Alias for {!Format.set_formatter_tag_functions} *) val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions (** Alias for {!Format.pp_get_formatter_tag_functions} *) val get_formatter_tag_functions : unit -> formatter_tag_functions (** Alias for {!Format.get_formatter_tag_functions} *) end stdcompat-10/stdcompat__fun.ml.in000066400000000000000000000015141350471256400172460ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Fun @END_FROM_4_08_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-10/stdcompat__fun.mli.in000066400000000000000000000000331350471256400174120ustar00rootroot00000000000000include Stdcompat__fun_s.S stdcompat-10/stdcompat__fun_s.mli.in000066400000000000000000000011661350471256400177440ustar00rootroot00000000000000module type S = sig exception Finally_raised of exn (** Alias for {!Fun.Finally_raised} *) 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-10/stdcompat__hashtbl.ml.in000066400000000000000000000241111350471256400201010ustar00rootroot00000000000000type 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 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) 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 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) 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 MakeSeeded = Hashtbl.MakeSeeded @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module MakeSeeded (H : SeededHashedType) = struct @BEGIN_FROM_4_00_0@ include Hashtbl.MakeSeeded(H) @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ include Hashtbl.Make(Stdcompat__hashtbl_ext.UnseedHashedType(H)) @END_BEFORE_4_00_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 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_4_07_0@ stdcompat-10/stdcompat__hashtbl.mli.in000066400000000000000000000000371350471256400202530ustar00rootroot00000000000000include Stdcompat__hashtbl_s.S stdcompat-10/stdcompat__hashtbl_ext.ml.in000066400000000000000000000116331350471256400207660ustar00rootroot00000000000000module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end @BEGIN_BEFORE_4_00_0@ module UnseedHashedType (H : SeededHashedType) = struct type t = H.t let equal = H.equal let hash = H.hash 0 end @END_BEFORE_4_00_0@ module MakeSeeded (H : SeededHashedType) = struct @BEGIN_FROM_4_00_0@ type 'a t = 'a Hashtbl.MakeSeeded(H).t @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ type 'a t = 'a Hashtbl.Make(UnseedHashedType(H)).t @END_BEFORE_4_00_0@ end 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-10/stdcompat__hashtbl_ext.mli.in000066400000000000000000000055271350471256400211440ustar00rootroot00000000000000module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end @BEGIN_BEFORE_4_00_0@ module UnseedHashedType (H : SeededHashedType) : Hashtbl.HashedType with type t = H.t @END_BEFORE_4_00_0@ module MakeSeeded (H : SeededHashedType) : sig @BEGIN_FROM_4_00_0@ type 'a t = 'a Hashtbl.MakeSeeded(H).t @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ type 'a t = 'a Hashtbl.Make(UnseedHashedType(H)).t @END_BEFORE_4_00_0@ end 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-10/stdcompat__hashtbl_s.mli.in000066400000000000000000000335061350471256400206040ustar00rootroot00000000000000module type S = sig type ('a, 'b) t = ('a, 'b) Hashtbl.t (** 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_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 @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 -> '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 @END_BEFORE_4_07_0@ (** @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 -> '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 @END_BEFORE_4_07_0@ (** @since 4.07.0: module Make = Hashtbl.Make *) @BEGIN_FROM_4_00_0@ module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end @END_FROM_4_00_0@ @BEGIN_BEFORE_4_00_0@ module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end @END_BEFORE_4_00_0@ (** @since 4.00.0: module type SeededHashedType = sig type t val equal : t -> t -> bool val hash : int -> t -> int end *) @BEGIN_FROM_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 @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 -> '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 @END_BEFORE_4_07_0@ (** @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_4_07_0@ module MakeSeeded = Hashtbl.MakeSeeded @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_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 -> '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 @END_BEFORE_4_07_0@ (** @since 4.07.0: module MakeSeeded = Hashtbl.MakeSeeded *) @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} *) val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c (** Alias for {!Hashtbl.fold} *) 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-10/stdcompat__init.ml.in000077700000000000000000000000001350471256400237032stdcompat__init.mli.inustar00rootroot00000000000000stdcompat-10/stdcompat__init.mli.in000066400000000000000000000030021350471256400175640ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ type 'a lazy_t = 'a CamlinternalLazy.t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ type 'a lazy_t_ = 'a lazy_t type 'a lazy_t = 'a lazy_t_ @END_BEFORE_4_08_0@ type in_channel_ = in_channel type in_channel = in_channel_ type out_channel_ = out_channel type out_channel = out_channel_ @BEGIN_FROM_4_06_0@ type nonrec floatarray = floatarray type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6 @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ type floatarray = float array @BEGIN_FROM_3_10_0@ type ('a, 'b, 'c, 'd, 'e, 'f) format6_ = ('a, 'b, 'c, 'd, 'e, 'f) format6 type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) format6_ @END_FROM_3_10_0@ @BEGIN_BEFORE_3_10_0@ type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'f) format4 @END_BEFORE_3_10_0@ @END_BEFORE_4_06_0@ @BEGIN_FROM_4_02_0@ type nonrec bytes = bytes @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type bytes = string @END_BEFORE_4_02_0@ type ('a, 'b) result = @BEGIN_FROM_4_03_0@ ('a, 'b) Pervasives.result = @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_RESULT_PKG@ ('a, 'b) Result.result = @END_WITH_RESULT_PKG@ @END_BEFORE_4_03_0@ | Ok of 'a | Error of 'b @BEGIN_FROM_4_07_0@ type 'a seq = unit -> 'a seq_node and 'a seq_node = 'a Seq.node = | Nil | Cons of 'a * 'a seq @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ type 'a seq = unit -> 'a seq_node and 'a seq_node = @BEGIN_WITH_SEQ_PKG@ 'a Seq.node = @END_WITH_SEQ_PKG@ | Nil | Cons of 'a * 'a seq @END_BEFORE_4_07_0@ stdcompat-10/stdcompat__int.ml.in000066400000000000000000000020241350471256400172450ustar00rootroot00000000000000@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-10/stdcompat__int.mli.in000066400000000000000000000000331350471256400174140ustar00rootroot00000000000000include Stdcompat__int_s.S stdcompat-10/stdcompat__int32.ml.in000066400000000000000000000047531350471256400174250ustar00rootroot00000000000000include Int32 @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@ stdcompat-10/stdcompat__int32.mli.in000066400000000000000000000000351350471256400175630ustar00rootroot00000000000000include Stdcompat__int32_s.S stdcompat-10/stdcompat__int32_s.mli.in000066400000000000000000000135211350471256400201110ustar00rootroot00000000000000module type S = sig type t = int32 (** Alias for {!Int32.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} *) @BEGIN_FROM_3_08_0@ external format : string -> int32 -> string = "caml_int32_format" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external format : string -> int32 -> string = "int32_format" @END_BEFORE_3_08_0@ (** @since 3.08.0: external format : string -> int32 -> string = "caml_int32_format" @since 3.07.0: external format : string -> int32 -> string = "int32_format" *) end stdcompat-10/stdcompat__int64.ml.in000066400000000000000000000016601350471256400174240ustar00rootroot00000000000000include Int64 @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@ stdcompat-10/stdcompat__int64.mli.in000066400000000000000000000000351350471256400175700ustar00rootroot00000000000000include Stdcompat__int64_s.S stdcompat-10/stdcompat__int64_s.mli.in000066400000000000000000000146651350471256400201300ustar00rootroot00000000000000module type S = sig type t = int64 (** Alias for {!Int64.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} *) @BEGIN_FROM_3_08_0@ external format : string -> int64 -> string = "caml_int64_format" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external format : string -> int64 -> string = "int64_format" @END_BEFORE_3_08_0@ (** @since 3.08.0: external format : string -> int64 -> string = "caml_int64_format" @since 3.07.0: external format : string -> int64 -> string = "int64_format" *) end stdcompat-10/stdcompat__int_s.mli.in000066400000000000000000000020471350471256400177450ustar00rootroot00000000000000module 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-10/stdcompat__lazy.ml.in000066400000000000000000000002121350471256400174270ustar00rootroot00000000000000include Lazy @BEGIN_BEFORE_4_00_0@ let from_fun = lazy_from_fun let from_val v = lazy v let is_val = lazy_is_val @END_BEFORE_4_00_0@ stdcompat-10/stdcompat__lazy.mli.in000066400000000000000000000000341350471256400176020ustar00rootroot00000000000000include Stdcompat__lazy_s.S stdcompat-10/stdcompat__lazy_s.mli.in000066400000000000000000000047711350471256400201400ustar00rootroot00000000000000module 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 from_fun : (unit -> 'a) -> 'a t (** @since 4.00.0: val from_fun : (unit -> 'a) -> 'a t *) val from_val : 'a -> 'a t (** @since 4.00.0: val from_val : 'a -> 'a t *) val is_val : 'a t -> bool (** @since 4.00.0: val is_val : 'a t -> bool *) @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} *) @BEGIN_FROM_4_08_0@ val lazy_from_fun : (unit -> 'a) -> 'a t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val lazy_from_fun : (unit -> 'a) -> 'a t @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lazy_from_fun : (unit -> 'a) -> 'a t @since 4.02.0: val lazy_from_fun : (unit -> 'a) -> 'a t[@@ocaml.deprecated "Use Lazy.from_fun instead."] @since 3.07.0: val lazy_from_fun : (unit -> 'a) -> 'a t *) @BEGIN_FROM_4_08_0@ val lazy_from_val : 'a -> 'a t @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val lazy_from_val : 'a -> 'a t @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lazy_from_val : 'a -> 'a t @since 4.02.0: val lazy_from_val : 'a -> 'a t[@@ocaml.deprecated "Use Lazy.from_val instead."] @since 3.07.0: val lazy_from_val : 'a -> 'a t *) @BEGIN_FROM_4_08_0@ val lazy_is_val : 'a t -> bool @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val lazy_is_val : 'a t -> bool @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lazy_is_val : 'a t -> bool @since 4.02.0: val lazy_is_val : 'a t -> bool[@@ocaml.deprecated "Use Lazy.is_val instead."] @since 3.07.0: val lazy_is_val : 'a t -> bool *) end stdcompat-10/stdcompat__lexing.ml.in000066400000000000000000000011021350471256400177350ustar00rootroot00000000000000include Lexing @BEGIN_BEFORE_4_08_0@ let from_channel ?with_positions chan = from_channel chan let from_string ?with_positions s = from_string s let from_function ?with_positions 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-10/stdcompat__lexing.mli.in000066400000000000000000000000361350471256400201130ustar00rootroot00000000000000include Stdcompat__lexing_s.S stdcompat-10/stdcompat__lexing_s.mli.in000066400000000000000000000074551350471256400204510ustar00rootroot00000000000000module 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 = { refill_buff: lexbuf -> unit ; mutable lex_buffer: Stdcompat__init.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_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 } *) 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 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-10/stdcompat__list.ml.in000066400000000000000000000044121350471256400174310ustar00rootroot00000000000000include 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_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 rec 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@ stdcompat-10/stdcompat__list.mli.in000066400000000000000000000000341350471256400175760ustar00rootroot00000000000000include Stdcompat__list_s.S stdcompat-10/stdcompat__listLabels.ml.in000066400000000000000000000033751350471256400205630ustar00rootroot00000000000000include ListLabels @BEGIN_BEFORE_4_08_0@ let filter_map ~f l = Stdcompat__list.filter_map f l @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_00_0@ let iteri ~f l = Stdcompat__list.iteri f l let mapi ~f l = Stdcompat__list.mapi f l @END_BEFORE_4_00_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) let sort_uniq ~cmp l = let cmp' a b = - (cmp a b) in let rev_l = sort cmp' l in uniq_rev_append cmp rev_l [] @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_05_0@ let cons x xs = x :: xs 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 ~len = if len < 0 then 1 else if len = 0 then if l = [] then 0 else 1 else match l with | [] -> -1 | _ :: tl -> compare_length_with tl ~len:(pred len) let nth_opt l n = Stdcompat__tools.option_find (nth l) n let find_opt ~f l = try Stdcompat__tools.option_find (find ~f:(Stdcompat__tools.pickle_predicate_not_found f)) 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 init ~len ~f = Stdcompat__list.init len f @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_07_0@ let to_seq = Stdcompat__list.to_seq let of_seq = Stdcompat__list.of_seq @END_BEFORE_4_07_0@ @BEGIN_BEFORE_4_08_0@ type 'a t = 'a list @BEGIN_FROM_4_03_0@ = [] | (::) of 'a * 'a list @END_FROM_4_03_0@ @END_BEFORE_4_08_0@ stdcompat-10/stdcompat__listLabels.mli.in000066400000000000000000000000421350471256400207200ustar00rootroot00000000000000include Stdcompat__listLabels_s.S stdcompat-10/stdcompat__listLabels_s.mli.in000066400000000000000000000136301350471256400212510ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @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 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} *) val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a (** Alias for {!ListLabels.fold_left} *) val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b (** Alias for {!ListLabels.fold_right} *) 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} *) val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a (** Alias for {!ListLabels.fold_left2} *) val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c (** Alias for {!ListLabels.fold_right2} *) val for_all : f:('a -> bool) -> 'a list -> bool (** Alias for {!ListLabels.for_all} *) val exists : f:('a -> bool) -> 'a list -> bool (** Alias for {!ListLabels.exists} *) val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!ListLabels.for_all2} *) val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!ListLabels.exists2} *) val mem : 'a -> set:'a list -> bool (** Alias for {!ListLabels.mem} *) val memq : 'a -> set:'a list -> bool (** Alias for {!ListLabels.memq} *) val find : f:('a -> bool) -> 'a list -> 'a (** Alias for {!ListLabels.find} *) val filter : f:('a -> bool) -> 'a list -> 'a list (** Alias for {!ListLabels.filter} *) val find_all : f:('a -> bool) -> 'a list -> 'a list (** Alias for {!ListLabels.find_all} *) val partition : f:('a -> bool) -> 'a list -> ('a list * 'a list) (** Alias for {!ListLabels.partition} *) val assoc : 'a -> ('a * 'b) list -> 'b (** Alias for {!ListLabels.assoc} *) val assq : 'a -> ('a * 'b) list -> 'b (** Alias for {!ListLabels.assq} *) val mem_assoc : 'a -> map:('a * 'b) list -> bool (** Alias for {!ListLabels.mem_assoc} *) val mem_assq : 'a -> map:('a * 'b) list -> bool (** Alias for {!ListLabels.mem_assq} *) val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!ListLabels.remove_assoc} *) val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!ListLabels.remove_assq} *) val split : ('a * 'b) list -> ('a list * 'b list) (** Alias for {!ListLabels.split} *) val combine : 'a list -> 'b list -> ('a * 'b) list (** Alias for {!ListLabels.combine} *) val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!ListLabels.sort} *) val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!ListLabels.stable_sort} *) val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!ListLabels.fast_sort} *) val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list (** Alias for {!ListLabels.merge} *) end stdcompat-10/stdcompat__list_s.mli.in000066400000000000000000000130261350471256400201250ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type 'a t = 'a list = | [] | (::) of 'a * 'a list @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 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} *) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a (** Alias for {!List.fold_left} *) val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b (** Alias for {!List.fold_right} *) 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} *) val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a (** Alias for {!List.fold_left2} *) val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c (** Alias for {!List.fold_right2} *) val for_all : ('a -> bool) -> 'a list -> bool (** Alias for {!List.for_all} *) val exists : ('a -> bool) -> 'a list -> bool (** Alias for {!List.exists} *) val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!List.for_all2} *) val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool (** Alias for {!List.exists2} *) val mem : 'a -> 'a list -> bool (** Alias for {!List.mem} *) val memq : 'a -> 'a list -> bool (** Alias for {!List.memq} *) val find : ('a -> bool) -> 'a list -> 'a (** Alias for {!List.find} *) val filter : ('a -> bool) -> 'a list -> 'a list (** Alias for {!List.filter} *) val find_all : ('a -> bool) -> 'a list -> 'a list (** Alias for {!List.find_all} *) val partition : ('a -> bool) -> 'a list -> ('a list * 'a list) (** Alias for {!List.partition} *) val assoc : 'a -> ('a * 'b) list -> 'b (** Alias for {!List.assoc} *) val assq : 'a -> ('a * 'b) list -> 'b (** Alias for {!List.assq} *) val mem_assoc : 'a -> ('a * 'b) list -> bool (** Alias for {!List.mem_assoc} *) val mem_assq : 'a -> ('a * 'b) list -> bool (** Alias for {!List.mem_assq} *) val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!List.remove_assoc} *) val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list (** Alias for {!List.remove_assq} *) val split : ('a * 'b) list -> ('a list * 'b list) (** Alias for {!List.split} *) val combine : 'a list -> 'b list -> ('a * 'b) list (** Alias for {!List.combine} *) val sort : ('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!List.sort} *) val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!List.stable_sort} *) val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list (** Alias for {!List.fast_sort} *) val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list (** Alias for {!List.merge} *) end stdcompat-10/stdcompat__map.ml.in000066400000000000000000000524651350471256400172460ustar00rootroot00000000000000module type OrderedType = Map.OrderedType 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) 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 @BEGIN_FROM_4_07_0@ module Make = Map.Make @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module Make (Ord : OrderedType) = struct include Map.Make (Ord) 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 @BEGIN_WITH_MAGIC@ type 'a internal = Empty | Node of 'a internal * key * 'a * 'a internal * int type 'a enumeration = End | More of key * 'a * 'a internal * 'a enumeration 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) = let m : 'a internal = Obj.magic m in seq_of_enum_ (cons_enum m End) let to_seq_from low (m : 'a t) = let m : 'a internal = Obj.magic m in 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 m End) @BEGIN_BEFORE_4_06_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 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_magic map = match map with | Empty -> raise Not_found | Node (l, v, d, _r, _h) -> min_binding_aux l v d 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 simple_merge t1 t2 = match t1, t2 with | Empty, t -> t | t, Empty -> t | _ -> let x, d = min_binding_magic t2 in bal t1 x d (remove_min_binding t2) let rec update_magic 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_magic x f l in if l == ll then m else bal ll v d r else let rr = update_magic x f r in if r == rr then m else bal l v d rr let update x f (map : 'a t) = let map : 'a internal = Obj.magic map in let result : 'a internal = update_magic x f map in Obj.magic result @END_BEFORE_4_06_0@ @BEGIN_BEFORE_4_05_0@ let min_binding_opt (map : 'a t) = let map : 'a internal = Obj.magic map in match 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) = let map : 'a internal = Obj.magic map in match map with | Empty -> None | Node (_l, v, d, r, _h) -> Some (max_binding_aux v d r) let max_binding_magic map = match map with | Empty -> raise Not_found | Node (_l, v, d, r, _h) -> max_binding_aux v d r let rec find_opt_magic 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_magic key (if c < 0 then l else r) let find_opt key (map : 'a t) = let map : 'a internal = Obj.magic map in find_opt_magic key 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_magic 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_magic p r let find_first_opt p (m : 'a t) = let m : 'a internal = Obj.magic m in find_first_opt_magic p m let rec find_first_magic 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_magic p r let find_first p (m : 'a t) = let m : 'a internal = Obj.magic m in find_first_magic p 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_magic 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_magic p l let find_last_opt p (m : 'a t) = let m : 'a internal = Obj.magic m in find_last_opt_magic p m let rec find_last_magic 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_magic p l let find_last p (m : 'a t) = let m : 'a internal = Obj.magic m in find_last_magic p m @END_BEFORE_4_05_0@ @BEGIN_BEFORE_3_12_0@ let min_binding (map : 'a t) = let map : 'a internal = Obj.magic map in min_binding_magic map let max_binding (map : 'a t) = let map : 'a internal = Obj.magic map in max_binding_magic map @END_BEFORE_3_12_0@ @BEGIN_BEFORE_4_03_0@ let singleton_magic v d = Node (Empty, v, d, Empty, 1) let rec add_min_binding k x map = match map with | Empty -> singleton_magic 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 -> singleton_magic 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_magic t2 in join t1 x d (remove_min_binding t2) let concat_or_join t1 v d t2 = match d with | Some d -> join t1 v d t2 | None -> concat t1 t2 let rec split_magic 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_magic x l in ll, pres, join rl v d r else let lr, pres, rr = split_magic x r in join l v d lr, pres, rr let rec union_magic 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_magic v1 s2 in let l = union_magic f l1 l2 and r = union_magic f r1 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_magic v2 s1 in let l = union_magic f l1 l2 and r = union_magic f 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 = let s1 : 'a internal = Obj.magic s1 in let s2 : 'a internal = Obj.magic s2 in let result : 'a internal = union_magic f s1 s2 in Obj.magic result @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) = let map : 'a internal = Obj.magic map in bindings_aux [] map let split x (map : 'a t) : ('a t * 'a option * 'a t) = let map : 'a internal = Obj.magic map in let (l : 'a internal), item, (r : 'a internal) = split_magic x map in (Obj.magic l, item, Obj.magic r) let rec merge_magic 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_magic v1 s2 in concat_or_join (merge_magic f l1 l2) v1 (f v1 (Some d1) d2) (merge_magic f r1 r2) | _, Node (l2, v2, d2, r2, _h2) -> let (l1, d1, r1) = split_magic v2 s1 in concat_or_join (merge_magic f l1 l2) v2 (f v2 d1 (Some d2)) (merge_magic f r1 r2) | _ -> assert false let merge (f : key -> 'a option -> 'b option -> 'c option) (map : 'a t) (map' : 'b t) : 'c t = let map : 'a internal = Obj.magic map in let map' : 'b internal = Obj.magic map' in let result : 'c internal = merge_magic f map map' in Obj.magic result let rec partition_magic p map = match map with | Empty -> Empty, Empty | Node (l, v, d, r, _h) -> let (lt, lf) = partition_magic p l in let pvd = p v d in let (rt, rf) = partition_magic 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 map : 'a internal = Obj.magic map in let (true_map : 'a internal), (false_map : 'a internal) = partition_magic p map in Obj.magic true_map, Obj.magic false_map let rec filter_magic p map = match map with | Empty -> Empty | Node (l, v, d, r, _h) as m -> let l' = filter_magic p l in let pvd = p v d in let r' = filter_magic 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 = Obj.magic map in let result : 'a internal = filter_magic p map in Obj.magic result let rec for_all_magic p = function | Empty -> true | Node (l, v, d, r, _h) -> p v d && for_all_magic p l && for_all_magic p r let for_all p (map : 'a t) = let map : 'a internal = Obj.magic map in for_all_magic p map let rec exists_magic p = function | Empty -> false | Node (l, v, d, r, _h) -> p v d || exists_magic p l || exists_magic p r let exists p (map : 'a t) = let map : 'a internal = Obj.magic map in exists_magic p map let compare_magic 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 = Obj.magic map in let map' : 'a internal = Obj.magic map' in compare_magic cmp map map' let equal_magic 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 = Obj.magic map in let map' : 'a internal = Obj.magic map' in equal_magic eq map map' @END_BEFORE_3_12_0@ @BEGIN_BEFORE_3_08_0@ let is_empty (map : 'a t) = match (Obj.magic map : 'a internal) with | Empty -> true | Node _ -> false @END_BEFORE_3_08_0@ @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ @BEGIN_BEFORE_3_12_0@ let bindings map = List.rev (fold (fun v d accu -> (v, d) :: accu) map []) @END_BEFORE_3_12_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) @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 let singleton key value = add key value empty @END_BEFORE_3_12_0@ end @END_BEFORE_4_07_0@ stdcompat-10/stdcompat__map.mli.in000066400000000000000000000000331350471256400173770ustar00rootroot00000000000000include Stdcompat__map_s.S stdcompat-10/stdcompat__map_s.mli.in000066400000000000000000000204521350471256400177300ustar00rootroot00000000000000module type S = sig module type OrderedType = sig type t val compare : t -> t -> int end (** Alias for {!Map.OrderedType} *) @BEGIN_FROM_4_07_0@ 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 @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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) 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_4_07_0@ (** @since 4.07.0: 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 *) @BEGIN_FROM_4_07_0@ module Make = Map.Make @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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 -> '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) 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_4_07_0@ (** @since 4.07.0: module Make = Map.Make *) end stdcompat-10/stdcompat__moreLabels.ml.in000066400000000000000000000244051350471256400205470ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ module Set = MoreLabels.Set @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ module Set = struct 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 Stdcompat__seq.t val to_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 (Ord : OrderedType) = struct include Stdcompat__set.Make (Ord) let iter ~f s = iter f s let map ~f s = map f s let fold ~f s ~init = fold f s init let for_all ~f s = for_all f s let exists ~f s = exists f s let filter ~f s = filter f s let partition ~f s = partition f s let find_first ~f s = find_first f s let find_first_opt ~f s = find_first_opt f s let find_last ~f s = find_last f s let find_last_opt ~f s = find_last_opt f s end end @END_BEFORE_4_08_0@ @BEGIN_FROM_4_07_0@ module Map = MoreLabels.Map module Hashtbl = MoreLabels.Hashtbl @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ module Map = struct 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) 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 (Ord : OrderedType) = struct include Stdcompat__map.Make (Ord) let add ~key ~data map = add key data map let update ~key ~f map = update key f map let merge ~f map map' = merge f map map' let union ~f map map' = union f map map' let compare ~cmp map map' = compare cmp map map' let equal ~cmp map map' = equal cmp map map' let iter ~f map = iter (fun key data -> f ~key ~data) map let fold ~f map ~init = fold (fun key data accu -> f ~key ~data accu) map init let for_all ~f map = for_all f map let exists ~f map = exists f map let filter ~f map = filter f map let partition ~f map = partition f map let find_first ~f map = find_first f map let find_first_opt ~f map = find_first_opt f map let find_last ~f map = find_last f map let find_last_opt ~f map = find_last_opt f map let map ~f m = map f m let mapi ~f m = mapi f m end end module Hashtbl = struct type ('a, 'b) t = ('a, 'b) Hashtbl.t let add t ~key ~data = Stdcompat__hashtbl.add t key data let replace t ~key ~data = Stdcompat__hashtbl.replace t key data let iter ~f t = Stdcompat__hashtbl.iter (fun key data -> f ~key ~data) t let filter_map_inplace ~f t = Stdcompat__hashtbl.filter_map_inplace (fun key data -> f ~key ~data) t let fold ~f t ~init = Stdcompat__hashtbl.fold (fun key data accu -> f ~key ~data accu) t init let create = Stdcompat__hashtbl.create let clear = Stdcompat__hashtbl.clear let reset = Stdcompat__hashtbl.reset let copy = Stdcompat__hashtbl.copy let find = Stdcompat__hashtbl.find let find_opt = Stdcompat__hashtbl.find_opt let find_all = Stdcompat__hashtbl.find_all let mem = Stdcompat__hashtbl.mem let remove = Stdcompat__hashtbl.remove let length = Stdcompat__hashtbl.length let randomize = Stdcompat__hashtbl.randomize let is_randomized = Stdcompat__hashtbl.is_randomized type statistics = Stdcompat__hashtbl_ext.statistics let stats = Stdcompat__hashtbl.stats let to_seq = Stdcompat__hashtbl.to_seq let to_seq_keys = Stdcompat__hashtbl.to_seq_keys let to_seq_values = Stdcompat__hashtbl.to_seq_values let add_seq = Stdcompat__hashtbl.add_seq let replace_seq = Stdcompat__hashtbl.replace_seq let of_seq = Stdcompat__hashtbl.of_seq let hash = Stdcompat__hashtbl.hash let seeded_hash = Stdcompat__hashtbl.seeded_hash let hash_param = Stdcompat__hashtbl.hash_param let seeded_hash_param = Stdcompat__hashtbl.seeded_hash_param module type HashedType = Hashtbl.HashedType module type SeededHashedType = Stdcompat__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) 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 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) 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 (H : HashedType) = struct include Stdcompat__hashtbl.Make (H) let add t ~key ~data = add t key data let replace t ~key ~data = replace t key data let iter ~f t = iter (fun key data -> f ~key ~data) t let filter_map_inplace ~f t = filter_map_inplace (fun key data -> f ~key ~data) t let fold ~f t ~init = fold (fun key data accu -> f ~key ~data accu) t init end module MakeSeeded (H : SeededHashedType) = struct include Stdcompat__hashtbl.MakeSeeded (H) let add t ~key ~data = add t key data let replace t ~key ~data = replace t key data let iter ~f t = iter (fun key data -> f ~key ~data) t let filter_map_inplace ~f t = filter_map_inplace (fun key data -> f ~key ~data) t let fold ~f t ~init = fold (fun key data accu -> f ~key ~data accu) t init end end @END_BEFORE_4_07_0@ stdcompat-10/stdcompat__moreLabels.mli.in000066400000000000000000000000421350471256400207070ustar00rootroot00000000000000include Stdcompat__moreLabels_s.S stdcompat-10/stdcompat__moreLabels_s.mli.in000066400000000000000000000346171350471256400212500ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_07_0@ module Hashtbl = MoreLabels.Hashtbl @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_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 -> '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 = Stdcompat__hashtbl_ext.statistics 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 = Hashtbl.HashedType module type SeededHashedType = Stdcompat__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) 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 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) 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 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) 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 and '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 -> 'b -> 'b) -> 'a t -> init:'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 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_4_07_0@ (** @since 4.07.0: module Hashtbl = MoreLabels.Hashtbl *) @BEGIN_FROM_4_07_0@ module Map = MoreLabels.Map @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ 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) 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 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) 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_4_07_0@ (** @since 4.07.0: module Map = MoreLabels.Map *) @BEGIN_FROM_4_08_0@ module Set = MoreLabels.Set @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ 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 Stdcompat__seq.t val to_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 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 Stdcompat__seq.t val to_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_4_08_0@ (** @since 4.08.0: module Set = MoreLabels.Set *) end stdcompat-10/stdcompat__native.ml_byte.in000066400000000000000000000000221350471256400207600ustar00rootroot00000000000000let native = falsestdcompat-10/stdcompat__native.ml_native.in000066400000000000000000000000211350471256400213020ustar00rootroot00000000000000let native = truestdcompat-10/stdcompat__native.mli000066400000000000000000000000221350471256400175010ustar00rootroot00000000000000val native : bool stdcompat-10/stdcompat__nativeint.ml.in000066400000000000000000000016641350471256400204650ustar00rootroot00000000000000include Nativeint @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@ stdcompat-10/stdcompat__nativeint.mli.in000066400000000000000000000000411350471256400206220ustar00rootroot00000000000000include Stdcompat__nativeint_s.S stdcompat-10/stdcompat__nativeint_s.mli.in000066400000000000000000000126321350471256400211550ustar00rootroot00000000000000module type S = sig type t = nativeint (** Alias for {!Nativeint.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} *) @BEGIN_FROM_3_08_0@ external format : string -> nativeint -> string = "caml_nativeint_format" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external format : string -> nativeint -> string = "nativeint_format" @END_BEFORE_3_08_0@ (** @since 3.08.0: external format : string -> nativeint -> string = "caml_nativeint_format" @since 3.07.0: external format : string -> nativeint -> string = "nativeint_format" *) end stdcompat-10/stdcompat__option.ml.in000066400000000000000000000024711350471256400177710ustar00rootroot00000000000000@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-10/stdcompat__option.mli.in000066400000000000000000000000361350471256400201350ustar00rootroot00000000000000include Stdcompat__option_s.S stdcompat-10/stdcompat__option_s.mli.in000066400000000000000000000044441350471256400204660ustar00rootroot00000000000000module 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-10/stdcompat__pervasives.ml.in000066400000000000000000000037721350471256400206550ustar00rootroot00000000000000include Pervasives @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-10/stdcompat__pervasives.mli.in000066400000000000000000000000421350471256400210110ustar00rootroot00000000000000include Stdcompat__pervasives_s.S stdcompat-10/stdcompat__pervasives_s.mli.in000066400000000000000000001037131350471256400213440ustar00rootroot00000000000000module type S = sig exception Exit type fpclass = Pervasives.fpclass = | 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 = Pervasives.open_flag = | 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 = Pervasives.LargeFile @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 = 'a Pervasives.ref = { 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 {!Pervasives.raise} *) val invalid_arg : string -> 'a (** Alias for {!Pervasives.invalid_arg} *) val failwith : string -> 'a (** Alias for {!Pervasives.failwith} *) external (=) : 'a -> 'a -> bool = "%equal" (** Alias for {!Pervasives.=} *) external (<>) : 'a -> 'a -> bool = "%notequal" (** Alias for {!Pervasives.<>} *) external (<) : 'a -> 'a -> bool = "%lessthan" (** Alias for {!Pervasives.<} *) external (>) : 'a -> 'a -> bool = "%greaterthan" (** Alias for {!Pervasives.>} *) external (<=) : 'a -> 'a -> bool = "%lessequal" (** Alias for {!Pervasives.<=} *) external (>=) : 'a -> 'a -> bool = "%greaterequal" (** Alias for {!Pervasives.>=} *) external compare : 'a -> 'a -> int = "%compare" (** Alias for {!Pervasives.compare} *) val min : 'a -> 'a -> 'a (** Alias for {!Pervasives.min} *) val max : 'a -> 'a -> 'a (** Alias for {!Pervasives.max} *) external (==) : 'a -> 'a -> bool = "%eq" (** Alias for {!Pervasives.==} *) external (!=) : 'a -> 'a -> bool = "%noteq" (** Alias for {!Pervasives.!=} *) external not : bool -> bool = "%boolnot" (** Alias for {!Pervasives.not} *) external (&&) : bool -> bool -> bool = "%sequand" (** Alias for {!Pervasives.&&} *) @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@ (** @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 {!Pervasives.||} *) @BEGIN_FROM_4_02_0@ external (or) : bool -> bool -> bool = "%sequor"[@@ocaml.deprecated "Use (||) instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external (or) : bool -> bool -> bool = "%sequor" @END_BEFORE_4_02_0@ (** @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 {!Pervasives.~-} *) external succ : int -> int = "%succint" (** Alias for {!Pervasives.succ} *) external pred : int -> int = "%predint" (** Alias for {!Pervasives.pred} *) external (+) : int -> int -> int = "%addint" (** Alias for {!Pervasives.+} *) external (-) : int -> int -> int = "%subint" (** Alias for {!Pervasives.-} *) external ( * ) : int -> int -> int = "%mulint" (** Alias for {!Pervasives.*} *) external (/) : int -> int -> int = "%divint" (** Alias for {!Pervasives./} *) external (mod) : int -> int -> int = "%modint" (** Alias for {!Pervasives.mod} *) val abs : int -> int (** Alias for {!Pervasives.abs} *) val max_int : int (** Alias for {!Pervasives.max_int} *) val min_int : int (** Alias for {!Pervasives.min_int} *) external (land) : int -> int -> int = "%andint" (** Alias for {!Pervasives.land} *) external (lor) : int -> int -> int = "%orint" (** Alias for {!Pervasives.lor} *) external (lxor) : int -> int -> int = "%xorint" (** Alias for {!Pervasives.lxor} *) val lnot : int -> int (** Alias for {!Pervasives.lnot} *) external (lsl) : int -> int -> int = "%lslint" (** Alias for {!Pervasives.lsl} *) external (lsr) : int -> int -> int = "%lsrint" (** Alias for {!Pervasives.lsr} *) external (asr) : int -> int -> int = "%asrint" (** Alias for {!Pervasives.asr} *) external (~-.) : float -> float = "%negfloat" (** Alias for {!Pervasives.~-.} *) external (+.) : float -> float -> float = "%addfloat" (** Alias for {!Pervasives.+.} *) external (-.) : float -> float -> float = "%subfloat" (** Alias for {!Pervasives.-.} *) external ( *. ) : float -> float -> float = "%mulfloat" (** Alias for {!Pervasives.*.} *) external (/.) : float -> float -> float = "%divfloat" (** Alias for {!Pervasives./.} *) @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 {!Pervasives.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 {!Pervasives.float} *) external float_of_int : int -> float = "%floatofint" (** Alias for {!Pervasives.float_of_int} *) external truncate : float -> int = "%intoffloat" (** Alias for {!Pervasives.truncate} *) external int_of_float : float -> int = "%intoffloat" (** Alias for {!Pervasives.int_of_float} *) val infinity : float (** Alias for {!Pervasives.infinity} *) val neg_infinity : float (** Alias for {!Pervasives.neg_infinity} *) val nan : float (** Alias for {!Pervasives.nan} *) val max_float : float (** Alias for {!Pervasives.max_float} *) val min_float : float (** Alias for {!Pervasives.min_float} *) val epsilon_float : float (** Alias for {!Pervasives.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 {!Pervasives.^} *) external int_of_char : char -> int = "%identity" (** Alias for {!Pervasives.int_of_char} *) val char_of_int : int -> char (** Alias for {!Pervasives.char_of_int} *) external ignore : 'a -> unit = "%ignore" (** Alias for {!Pervasives.ignore} *) val string_of_bool : bool -> string (** Alias for {!Pervasives.string_of_bool} *) val bool_of_string : string -> bool (** Alias for {!Pervasives.bool_of_string} *) val string_of_int : int -> string (** Alias for {!Pervasives.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 {!Pervasives.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" *) external fst : ('a * 'b) -> 'a = "%field0" (** Alias for {!Pervasives.fst} *) external snd : ('a * 'b) -> 'b = "%field1" (** Alias for {!Pervasives.snd} *) val (@) : 'a list -> 'a list -> 'a list (** Alias for {!Pervasives.@} *) val print_char : char -> unit (** Alias for {!Pervasives.print_char} *) val print_string : string -> unit (** Alias for {!Pervasives.print_string} *) val print_int : int -> unit (** Alias for {!Pervasives.print_int} *) val print_float : float -> unit (** Alias for {!Pervasives.print_float} *) val print_endline : string -> unit (** Alias for {!Pervasives.print_endline} *) val print_newline : unit -> unit (** Alias for {!Pervasives.print_newline} *) val prerr_char : char -> unit (** Alias for {!Pervasives.prerr_char} *) val prerr_string : string -> unit (** Alias for {!Pervasives.prerr_string} *) val prerr_int : int -> unit (** Alias for {!Pervasives.prerr_int} *) val prerr_float : float -> unit (** Alias for {!Pervasives.prerr_float} *) val prerr_endline : string -> unit (** Alias for {!Pervasives.prerr_endline} *) val prerr_newline : unit -> unit (** Alias for {!Pervasives.prerr_newline} *) val read_line : unit -> string (** Alias for {!Pervasives.read_line} *) val read_int : unit -> int (** Alias for {!Pervasives.read_int} *) val read_float : unit -> float (** Alias for {!Pervasives.read_float} *) val flush_all : unit -> unit (** Alias for {!Pervasives.flush_all} *) external ref : 'a -> 'a ref = "%makemutable" (** Alias for {!Pervasives.ref} *) external (!) : 'a ref -> 'a = "%field0" (** Alias for {!Pervasives.!} *) external (:=) : 'a ref -> 'a -> unit = "%setfield0" (** Alias for {!Pervasives.:=} *) external incr : int ref -> unit = "%incr" (** Alias for {!Pervasives.incr} *) external decr : int ref -> unit = "%decr" (** Alias for {!Pervasives.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 {!Pervasives.exit} *) val at_exit : (unit -> unit) -> unit (** Alias for {!Pervasives.at_exit} *) val valid_float_lexem : string -> string (** Alias for {!Pervasives.valid_float_lexem} *) val do_at_exit : unit -> unit (** Alias for {!Pervasives.do_at_exit} *) end stdcompat-10/stdcompat__printexc.ml.in000066400000000000000000000076421350471256400203220ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Printexc @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@ @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@ @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@ @BEGIN_FROM_4_02_0@ type location = Printexc.location = { filename: string ; line_number: int ; start_char: int ; end_char: int } @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } @END_BEFORE_4_02_0@ @BEGIN_FROM_4_04_0@ module Slot = Printexc.Slot @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ module Slot = struct 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 _ = failwith "Unimplemented." let location _ = failwith "Unimplemented." let format _ _ = failwith "Unimplemented." @END_BEFORE_4_02_0@ let is_inline _ = failwith "Unimplemented." end @END_BEFORE_4_04_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 _ = failwith "Unimplemented." @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 _ = failwith "Unimplemented." let backtrace_slots _ = failwith "Unimplemented." let raw_backtrace_length _ = failwith "Unimplemented." let get_raw_backtrace_slot _ = failwith "Unimplemented." let convert_raw_backtrace_slot _ = failwith "Unimplemented." let exn_slot_id _ = failwith "Unimplemented." let exn_slot_name _ = failwith "Unimplemented." @END_BEFORE_4_02_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 let get_callstack = Printexc.get_callstack @END_FROM_4_01_0@ @BEGIN_BEFORE_4_01_0@ let get_raw_backtrace _ = () let print_raw_backtrace _ = failwith "Unimplemented." let raw_backtrace_to_string _ = failwith "Unimplemented." let get_callstack _ = failwith "Unimplemented." @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 _ = failwith "Unimplemented." let get_backtrace _ = failwith "Unimplemented." let record_backtrace _ = failwith "Unimplemented." let backtrace_status _ = failwith "Unimplemented." let register_printer _ = failwith "Unimplemented." @END_BEFORE_3_11_0@ let to_string = Printexc.to_string let print = Printexc.print let catch = Printexc.catch stdcompat-10/stdcompat__printexc.mli.in000066400000000000000000000000401350471256400204540ustar00rootroot00000000000000include Stdcompat__printexc_s.S stdcompat-10/stdcompat__printexc_s.mli.in000066400000000000000000000104571350471256400210130ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ type t = exn = .. @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_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_4_02_0@ type location = Printexc.location = { filename: string ; line_number: int ; start_char: int ; end_char: int } @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } @END_BEFORE_4_02_0@ (** @since 4.02.0: type location = { filename: string ; line_number: int ; start_char: int ; end_char: int } *) @BEGIN_FROM_4_04_0@ module Slot = Printexc.Slot @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ 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 @END_BEFORE_4_04_0@ (** @since 4.04.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 *) @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 *) val get_callstack : int -> raw_backtrace (** @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-10/stdcompat__printf.ml.in000066400000000000000000000005141350471256400177570ustar00rootroot00000000000000let not_implemented _ = failwith "Stdcompat.Printf is not implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." let ifprintf = not_implemented let ikfprintf = not_implemented let kbprintf = not_implemented let kfprintf = not_implemented let ksprintf = not_implemented include Printf stdcompat-10/stdcompat__printf.mli.in000066400000000000000000000000361350471256400201270ustar00rootroot00000000000000include Stdcompat__printf_s.S stdcompat-10/stdcompat__printf_s.mli.in000066400000000000000000000064771350471256400204700ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_03_0@ val ifprintf : 'b -> ('a, 'b, 'c, unit) format4 -> 'a @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val ifprintf : 'b -> ('a, 'b, unit) format -> 'a @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 @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val ikfprintf : (out_channel -> 'a) -> out_channel -> ('b, out_channel, unit, 'a) format4 -> 'b @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-10/stdcompat__queue.ml.in000066400000000000000000000030301350471256400175750ustar00rootroot00000000000000include 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@ 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@ stdcompat-10/stdcompat__queue.mli.in000066400000000000000000000000351350471256400177500ustar00rootroot00000000000000include Stdcompat__queue_s.S stdcompat-10/stdcompat__queue_s.mli.in000066400000000000000000000037601350471256400203020ustar00rootroot00000000000000module type S = sig type 'a t = 'a Queue.t (** 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_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@ (** @since 4.00.0: val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b @since 3.07.0: val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a *) val transfer : 'a t -> 'a t -> unit (** Alias for {!Queue.transfer} *) end stdcompat-10/stdcompat__result.ml.in000066400000000000000000000032741350471256400200010ustar00rootroot00000000000000@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-10/stdcompat__result.mli.in000066400000000000000000000000361350471256400201430ustar00rootroot00000000000000include Stdcompat__result_s.S stdcompat-10/stdcompat__result_s.mli.in000066400000000000000000000141071350471256400204710ustar00rootroot00000000000000module 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-10/stdcompat__root.ml.in000066400000000000000000000001211350471256400174320ustar00rootroot00000000000000type bytes = Stdcompat__init.bytes type floatarray = Stdcompat__init.floatarray stdcompat-10/stdcompat__root.mli.in000066400000000000000000000002501350471256400176060ustar00rootroot00000000000000type 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-10/stdcompat__seq.ml.in000066400000000000000000000025541350471256400172530ustar00rootroot00000000000000@BEGIN_FROM_4_07_0@ include Seq @END_FROM_4_07_0@ @BEGIN_BEFORE_4_07_0@ @BEGIN_WITH_SEQ_PKG@ include Seq @END_WITH_SEQ_PKG@ @BEGIN_WITHOUT_SEQ_PKG@ type 'a t = unit -> 'a node and 'a node = 'a Stdcompat__init.seq_node = | Nil | Cons of 'a * 'a t let empty () = Nil let return x () = Cons (x, empty) let rec map f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> Cons (f x, map f next) let rec filter_map f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> match f x with | None -> filter_map f next () | Some y -> Cons (y, filter_map f next) let rec filter f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> if f x then Cons (x, filter f next) else filter f next () let rec flat_map f seq () = match seq () with | Nil -> Nil | Cons (x, next) -> flat_map_app f (f x) next () and flat_map_app f seq tail () = match seq () with | Nil -> flat_map f tail () | Cons (x, next) -> Cons (x, flat_map_app f next tail) let fold_left f acc seq = let rec aux f acc seq = match seq () with | Nil -> acc | Cons (x, next) -> let acc = f acc x in aux f acc next in aux f acc seq let iter f seq = let rec aux seq = match seq () with | Nil -> () | Cons (x, next) -> f x; aux next in aux seq @END_WITHOUT_SEQ_PKG@ @END_BEFORE_4_07_0@ stdcompat-10/stdcompat__seq.mli.in000066400000000000000000000000331350471256400174120ustar00rootroot00000000000000include Stdcompat__seq_s.S stdcompat-10/stdcompat__seq_s.mli.in000066400000000000000000000022701350471256400177410ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_07_0@ type 'a t = unit -> 'a node and 'a node = 'a 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 *) 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 *) val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a (** @since 4.07.0: val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a *) val iter : ('a -> unit) -> 'a t -> unit (** @since 4.07.0: val iter : ('a -> unit) -> 'a t -> unit *) end stdcompat-10/stdcompat__set.ml.in000066400000000000000000000215451350471256400172570ustar00rootroot00000000000000module type OrderedType = Set.OrderedType 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 Stdcompat__seq.t val to_seq : t -> elt Stdcompat__seq.t val add_seq : elt Stdcompat__seq.t -> t -> t val of_seq : elt Stdcompat__seq.t -> t end @BEGIN_FROM_4_08_0@ module Make = Set.Make @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ module Make (Ord : OrderedType) = struct include Set.Make (Ord) let disjoint s s' = is_empty (inter s s') @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@ type internal = Empty | Node of internal * elt * internal * int type enumeration = End | More of elt * internal * enumeration 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 = Obj.magic s in seq_of_enum_ (cons_enum s End) let to_seq_from low s = let s : internal = Obj.magic 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 = Obj.magic 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 = Obj.magic 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 = Obj.magic 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 = Obj.magic 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 = Obj.magic 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 = Obj.magic 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_02_0@ let of_list l = List.fold_left (fun s item -> add item s) empty l @END_BEFORE_4_02_0@ @BEGIN_BEFORE_4_04_0@ @BEGIN_WITH_MAGIC@ let rec map_internal f = function | Empty -> Empty | Node (l, v, r, _h) as t -> let l' = map_internal f l in let v' = f v in let r' = map_internal f r in if l == l' && v == v' && r == r' then t else (* This is less efficient than the standard library implementation: the latter relies on the internal function try_join that would require to backport too much of code. *) Obj.magic (union (Obj.magic l') (add v' (Obj.magic r'))) let map f s = let s : internal = Obj.magic s in (Obj.magic (map_internal f s) : t) @END_WITH_MAGIC@ @BEGIN_WITHOUT_MAGIC@ type map_changed = | Changed of t | Unchanged of elt list 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@ end @END_BEFORE_4_08_0@ stdcompat-10/stdcompat__set.mli.in000066400000000000000000000000331350471256400174150ustar00rootroot00000000000000include Stdcompat__set_s.S stdcompat-10/stdcompat__set_s.mli.in000066400000000000000000000150431350471256400177460ustar00rootroot00000000000000module type S = sig module type OrderedType = sig type t val compare : t -> t -> int end (** Alias for {!Set.OrderedType} *) @BEGIN_FROM_4_08_0@ 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 @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ 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 Stdcompat__seq.t val to_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_4_08_0@ (** @since 4.08.0: 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 *) @BEGIN_FROM_4_08_0@ module Make = Set.Make @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ 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 : (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 Stdcompat__seq.t val to_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_4_08_0@ (** @since 4.08.0: module Make = Set.Make *) end stdcompat-10/stdcompat__spacetime.ml.in000066400000000000000000000012351350471256400204300ustar00rootroot00000000000000@BEGIN_FROM_4_04_0@ include Spacetime @BEGIN_BEFORE_4_05_0@ let enabled = false @END_BEFORE_4_05_0@ @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ let not_implemented () = failwith "Stdcompat.Spacetime is not implemented yet. Please fill an issue: https://github.com/thierry-martinez/stdcompat/issues ." let enabled = false module Series = struct type t let create ~path = not_implemented () let save_event ?time _ ~event_name = not_implemented () let save_and_close ?time _ = not_implemented () end module Snapshot = struct let take ?time _ = not_implemented () end let save_event_for_automatic_snapshots ~event_name = not_implemented () @END_BEFORE_4_04_0@ stdcompat-10/stdcompat__spacetime.mli.in000066400000000000000000000000411350471256400205730ustar00rootroot00000000000000include Stdcompat__spacetime_s.S stdcompat-10/stdcompat__spacetime_s.mli.in000066400000000000000000000015111350471256400211200ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_04_0@ module Series = Spacetime.Series @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ 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 @END_BEFORE_4_04_0@ (** @since 4.04.0: module Series = Spacetime.Series *) @BEGIN_FROM_4_04_0@ module Snapshot = Spacetime.Snapshot @END_FROM_4_04_0@ @BEGIN_BEFORE_4_04_0@ module Snapshot : sig val take : ?time:float -> Series.t -> unit end @END_BEFORE_4_04_0@ (** @since 4.04.0: module Snapshot = Spacetime.Snapshot *) val enabled : bool (** @since 4.05.0: val enabled : bool *) val save_event_for_automatic_snapshots : event_name:string -> unit (** @since 4.04.0: val save_event_for_automatic_snapshots : event_name:string -> unit *) end stdcompat-10/stdcompat__stack.ml.in000066400000000000000000000025241350471256400175650ustar00rootroot00000000000000include 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@ stdcompat-10/stdcompat__stack.mli.in000066400000000000000000000000351350471256400177310ustar00rootroot00000000000000include Stdcompat__stack_s.S stdcompat-10/stdcompat__stack_s.mli.in000066400000000000000000000030741350471256400202610ustar00rootroot00000000000000module type S = sig type 'a t = 'a Stack.t (** Alias for {!Stack.t} *) exception Empty (** Alias for {!Stack.Empty} *) 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_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 fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b (** @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-10/stdcompat__stdlabels.mli000066400000000000000000000000411350471256400201710ustar00rootroot00000000000000include Stdcompat__stdlabels_s.S stdcompat-10/stdcompat__stdlib.ml.in000066400000000000000000000045131350471256400177410ustar00rootroot00000000000000@BEGIN_FROM_4_08_0@ include Stdlib @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ module Pervasives = Stdcompat__pervasives include Pervasives module Arg = Stdcompat__arg module Array = Stdcompat__array module ArrayLabels = Stdcompat__arrayLabels (* 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 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 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 Parsing = Parsing module Printexc = Stdcompat__printexc module Printf = Stdcompat__printf module Queue = Stdcompat__queue module Random = Random module Result = Stdcompat__result module Scanf = Scanf module Seq = Stdcompat__seq module Set = Stdcompat__set module Sort = Sort module Spacetime = Stdcompat__spacetime 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 Stream = Stdcompat__stream module String = Stdcompat__string module StringLabels = Stdcompat__stringLabels module Sys = Stdcompat__sys module Uchar = Stdcompat__uchar module Weak = Stdcompat__weak @END_BEFORE_4_08_0@ stdcompat-10/stdcompat__stdlib.mli.in000066400000000000000000000000361350471256400201060ustar00rootroot00000000000000include Stdcompat__stdlib_s.S stdcompat-10/stdcompat__stdlib_s.mli.in000066400000000000000000000064311350471256400204350ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_08_0@ include module type of struct include Stdlib end @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ module Pervasives : Stdcompat__pervasives_s.S include Stdcompat__pervasives_s.S module Arg : Stdcompat__arg_s.S module Array : Stdcompat__array_s.S module ArrayLabels : Stdcompat__arrayLabels_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 Ephemeron : Stdcompat__ephemeron_s.S module Filename : Stdcompat__filename_s.S module Float : Stdcompat__float_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@ @BEGIN_FROM_3_12_0@ module Genlex : module type of (struct include Genlex end) @END_FROM_3_12_0@ module Hashtbl : Stdcompat__hashtbl_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 @BEGIN_FROM_3_12_0@ module Random : module type of (struct include Random end) @END_FROM_3_12_0@ 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 Spacetime : Stdcompat__spacetime_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 Stream : Stdcompat__stream_s.S 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 Weak : Stdcompat__weak_s.S @END_BEFORE_4_08_0@ end stdcompat-10/stdcompat__stream.ml.in000066400000000000000000000001231350471256400177440ustar00rootroot00000000000000include Stream @BEGIN_BEFORE_4_03_0@ let of_bytes = of_string @END_BEFORE_4_03_0@ stdcompat-10/stdcompat__stream.mli.in000066400000000000000000000000361350471256400201200ustar00rootroot00000000000000include Stdcompat__stream_s.S stdcompat-10/stdcompat__stream_s.mli.in000066400000000000000000000032741350471256400204510ustar00rootroot00000000000000module type S = sig type 'a t = 'a Stream.t (** Alias for {!Stream.t} *) exception Failure (** Alias for {!Stream.Failure} *) exception Error of string (** Alias for {!Stream.Error} *) @BEGIN_FROM_4_02_0@ val of_bytes : bytes -> char t @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val of_bytes : Stdcompat__init.bytes -> char t @END_BEFORE_4_02_0@ (** @since 4.02.0: val of_bytes : bytes -> char t *) val from : (int -> 'a option) -> 'a t (** Alias for {!Stream.from} *) val of_list : 'a list -> 'a t (** Alias for {!Stream.of_list} *) val of_string : string -> char t (** Alias for {!Stream.of_string} *) val of_channel : in_channel -> char t (** Alias for {!Stream.of_channel} *) val iter : ('a -> unit) -> 'a t -> unit (** Alias for {!Stream.iter} *) val next : 'a t -> 'a (** Alias for {!Stream.next} *) val empty : 'a t -> unit (** Alias for {!Stream.empty} *) val peek : 'a t -> 'a option (** Alias for {!Stream.peek} *) val junk : 'a t -> unit (** Alias for {!Stream.junk} *) val count : 'a t -> int (** Alias for {!Stream.count} *) val npeek : int -> 'a t -> 'a list (** Alias for {!Stream.npeek} *) val iapp : 'a t -> 'a t -> 'a t (** Alias for {!Stream.iapp} *) val icons : 'a -> 'a t -> 'a t (** Alias for {!Stream.icons} *) val ising : 'a -> 'a t (** Alias for {!Stream.ising} *) val lapp : (unit -> 'a t) -> 'a t -> 'a t (** Alias for {!Stream.lapp} *) val lcons : (unit -> 'a) -> 'a t -> 'a t (** Alias for {!Stream.lcons} *) val lsing : (unit -> 'a) -> 'a t (** Alias for {!Stream.lsing} *) val sempty : 'a t (** Alias for {!Stream.sempty} *) val slazy : (unit -> 'a t) -> 'a t (** Alias for {!Stream.slazy} *) val dump : ('a -> unit) -> 'a t -> unit (** Alias for {!Stream.dump} *) end stdcompat-10/stdcompat__string.ml.in000066400000000000000000000041721350471256400177670ustar00rootroot00000000000000include 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 = 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_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 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@ stdcompat-10/stdcompat__string.mli.in000066400000000000000000000000361350471256400201330ustar00rootroot00000000000000include Stdcompat__string_s.S stdcompat-10/stdcompat__stringLabels.ml.in000066400000000000000000000031601350471256400211060ustar00rootroot00000000000000include StringLabels @BEGIN_BEFORE_3_08_0@ type t = string @END_BEFORE_3_08_0@ @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 lowercase_ascii = lowercase let uppercase_ascii = uppercase let capitalize_ascii = capitalize let uncapitalize_ascii = uncapitalize let equal : t -> t -> bool = ( = ) let split_on_char ~sep 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 = sep then begin accu := sub s (i + 1) (!previous_index - i - 1) :: !accu; previous_index := i end done; sub s 0 !previous_index :: !accu 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_02_0@ 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 trim s = Stdcompat__string.trim s @END_BEFORE_4_00_0@ @BEGIN_BEFORE_3_08_0@ let compare : t -> t -> int = compare @END_BEFORE_3_08_0@ stdcompat-10/stdcompat__stringLabels.mli.in000066400000000000000000000000441350471256400212550ustar00rootroot00000000000000include Stdcompat__stringLabels_s.S stdcompat-10/stdcompat__stringLabels_s.mli.in000066400000000000000000000316731350471256400216130ustar00rootroot00000000000000module 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 *) @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_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 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 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 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 *) @BEGIN_FROM_4_08_0@ external set : bytes -> int -> char -> unit = "%string_safe_set" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external set : Stdcompat__init.bytes -> int -> char -> unit = "%string_safe_set" @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external set : bytes -> int -> char -> unit = "%string_safe_set" @since 4.02.0: external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use BytesLabels.set instead."] *) @BEGIN_FROM_4_08_0@ external create : int -> bytes = "caml_create_string" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external create : int -> Stdcompat__init.bytes = "caml_create_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external create : int -> Stdcompat__init.bytes = "create_string" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external create : int -> bytes = "caml_create_string" @since 4.02.0: external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use BytesLabels.create instead."] *) val init : int -> f:(int -> char) -> string (** @since 4.02.0: val init : int -> f:(int -> char) -> string *) @BEGIN_FROM_4_08_0@ val fill : bytes -> pos:int -> len:int -> char -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] @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@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val fill : bytes -> pos:int -> len:int -> char -> unit @since 4.02.0: val fill : bytes -> pos:int -> len:int -> char -> unit[@@ocaml.deprecated "Use BytesLabels.fill instead."] *) @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_08_0@ external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external unsafe_set : Stdcompat__init.bytes -> int -> char -> unit = "%string_unsafe_set" @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" @since 4.02.0: external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] *) @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" *) @BEGIN_FROM_4_08_0@ external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@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" [@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external unsafe_fill : Stdcompat__init.bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_fill : Stdcompat__init.bytes -> pos:int -> len:int -> char -> unit = "fill_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" [@@noalloc ] @since 4.03.0: external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] [@@noalloc ] @since 4.02.0: external unsafe_fill : bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc" [@@ocaml.deprecated "- : bytes -> pos:int -> len:int -> char -> unit = "] *) val iteri : f:(int -> char -> unit) -> string -> unit (** @since 4.00.0: val iteri : f:(int -> char -> unit) -> string -> unit *) 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 compare : t -> t -> int (** @since 3.08.0: val compare : t -> t -> int *) external length : string -> int = "%string_length" (** Alias for {!StringLabels.length} *) external get : string -> int -> char = "%string_safe_get" (** Alias for {!StringLabels.get} *) val make : int -> char -> string (** Alias for {!StringLabels.make} *) @BEGIN_FROM_4_08_0@ val copy : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_06_0@ val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] @END_FROM_4_06_0@ @BEGIN_BEFORE_4_06_0@ val copy : string -> string @END_BEFORE_4_06_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val copy : string -> string @since 4.06.0: val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] @since 3.07.0: val copy : string -> string *) val sub : string -> pos:int -> len:int -> string (** Alias for {!StringLabels.sub} *) val concat : sep:string -> string list -> string (** Alias for {!StringLabels.concat} *) val iter : f:(char -> unit) -> string -> unit (** Alias for {!StringLabels.iter} *) val escaped : string -> string (** Alias for {!StringLabels.escaped} *) val index : string -> char -> int (** Alias for {!StringLabels.index} *) val rindex : string -> char -> int (** Alias for {!StringLabels.rindex} *) 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 contains : string -> char -> bool (** Alias for {!StringLabels.contains} *) val contains_from : string -> int -> char -> bool (** Alias for {!StringLabels.contains_from} *) val rcontains_from : string -> int -> char -> bool (** Alias for {!StringLabels.rcontains_from} *) @BEGIN_FROM_4_08_0@ val uppercase : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val uppercase : string -> string @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uppercase : string -> string @since 4.05.0: val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] @since 3.07.0: val uppercase : string -> string *) @BEGIN_FROM_4_08_0@ val lowercase : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val lowercase : string -> string @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lowercase : string -> string @since 4.05.0: val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] @since 3.07.0: val lowercase : string -> string *) @BEGIN_FROM_4_08_0@ val capitalize : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val capitalize : string -> string @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val capitalize : string -> string @since 4.05.0: val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] @since 3.07.0: val capitalize : string -> string *) @BEGIN_FROM_4_08_0@ val uncapitalize : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_05_0@ val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] @END_FROM_4_05_0@ @BEGIN_BEFORE_4_05_0@ val uncapitalize : string -> string @END_BEFORE_4_05_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uncapitalize : string -> string @since 4.05.0: val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] @since 3.07.0: val uncapitalize : string -> string *) external unsafe_get : string -> int -> char = "%string_unsafe_get" (** Alias for {!StringLabels.unsafe_get} *) end stdcompat-10/stdcompat__string_s.mli.in000066400000000000000000000304541350471256400204640ustar00rootroot00000000000000module type S = sig type t = string (** Alias for {!String.t} *) @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_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 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 split_on_char : char -> string -> string list (** @since 4.04.0: val split_on_char : char -> string -> string list *) 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 equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) @BEGIN_FROM_4_08_0@ external set : bytes -> int -> char -> unit = "%string_safe_set" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external set : Stdcompat__init.bytes -> int -> char -> unit = "%string_safe_set" @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external set : bytes -> int -> char -> unit = "%string_safe_set" @since 4.02.0: external set : bytes -> int -> char -> unit = "%string_safe_set"[@@ocaml.deprecated "Use Bytes.set instead."] *) @BEGIN_FROM_4_08_0@ external create : int -> bytes = "caml_create_string" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external create : int -> Stdcompat__init.bytes = "caml_create_string" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external create : int -> Stdcompat__init.bytes = "create_string" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external create : int -> bytes = "caml_create_string" @since 4.02.0: external create : int -> bytes = "caml_create_string"[@@ocaml.deprecated "Use Bytes.create instead."] *) val init : int -> (int -> char) -> string (** @since 4.02.0: val init : int -> (int -> char) -> string *) @BEGIN_FROM_4_08_0@ val fill : bytes -> int -> int -> char -> unit @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val fill : Stdcompat__init.bytes -> int -> int -> char -> unit @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val fill : bytes -> int -> int -> char -> unit @since 4.02.0: val fill : bytes -> int -> int -> char -> unit[@@ocaml.deprecated "Use Bytes.fill instead."] *) @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_08_0@ external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ external unsafe_set : Stdcompat__init.bytes -> int -> char -> unit = "%string_unsafe_set" @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" @since 4.02.0: external unsafe_set : bytes -> int -> char -> unit = "%string_unsafe_set" [@@ocaml.deprecated "- : bytes -> int -> char -> unit = "] *) @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" *) @BEGIN_FROM_4_08_0@ external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@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"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ @BEGIN_FROM_3_08_0@ external unsafe_fill : Stdcompat__init.bytes -> int -> int -> char -> unit = "caml_fill_string" "noalloc" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external unsafe_fill : Stdcompat__init.bytes -> int -> int -> char -> unit = "fill_string" "noalloc" @END_BEFORE_3_08_0@ @END_BEFORE_4_02_0@ @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@noalloc ] @since 4.03.0: external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] [@@noalloc ] @since 4.02.0: external unsafe_fill : bytes -> int -> int -> char -> unit = "caml_fill_string" "noalloc"[@@ocaml.deprecated "- : bytes -> int -> int -> char -> unit = "] *) val iteri : (int -> char -> unit) -> string -> unit (** @since 4.00.0: val iteri : (int -> char -> unit) -> string -> unit *) 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 *) external length : string -> int = "%string_length" (** Alias for {!String.length} *) external get : string -> int -> char = "%string_safe_get" (** Alias for {!String.get} *) val make : int -> char -> string (** Alias for {!String.make} *) @BEGIN_FROM_4_08_0@ val copy : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_02_0@ val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] @END_FROM_4_02_0@ @BEGIN_BEFORE_4_02_0@ val copy : string -> string @END_BEFORE_4_02_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val copy : string -> string @since 4.02.0: val copy : string -> string[@@ocaml.deprecated "- : string -> string = "] @since 3.07.0: val copy : string -> string *) val sub : string -> int -> int -> string (** Alias for {!String.sub} *) val concat : string -> string list -> string (** Alias for {!String.concat} *) val iter : (char -> unit) -> string -> unit (** Alias for {!String.iter} *) val escaped : string -> string (** Alias for {!String.escaped} *) val index : string -> char -> int (** Alias for {!String.index} *) val rindex : string -> char -> int (** Alias for {!String.rindex} *) 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 contains : string -> char -> bool (** Alias for {!String.contains} *) val contains_from : string -> int -> char -> bool (** Alias for {!String.contains_from} *) val rcontains_from : string -> int -> char -> bool (** Alias for {!String.rcontains_from} *) @BEGIN_FROM_4_08_0@ val uppercase : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val uppercase : string -> string @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uppercase : string -> string @since 4.03.0: val uppercase : string -> string[@@ocaml.deprecated "Use String.uppercase_ascii instead."] @since 3.07.0: val uppercase : string -> string *) @BEGIN_FROM_4_08_0@ val lowercase : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val lowercase : string -> string @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val lowercase : string -> string @since 4.03.0: val lowercase : string -> string[@@ocaml.deprecated "Use String.lowercase_ascii instead."] @since 3.07.0: val lowercase : string -> string *) @BEGIN_FROM_4_08_0@ val capitalize : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val capitalize : string -> string @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val capitalize : string -> string @since 4.03.0: val capitalize : string -> string[@@ocaml.deprecated "Use String.capitalize_ascii instead."] @since 3.07.0: val capitalize : string -> string *) @BEGIN_FROM_4_08_0@ val uncapitalize : string -> string @END_FROM_4_08_0@ @BEGIN_BEFORE_4_08_0@ @BEGIN_FROM_4_03_0@ val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ val uncapitalize : string -> string @END_BEFORE_4_03_0@ @END_BEFORE_4_08_0@ (** @since 4.08.0: val uncapitalize : string -> string @since 4.03.0: val uncapitalize : string -> string[@@ocaml.deprecated "Use String.uncapitalize_ascii instead."] @since 3.07.0: val uncapitalize : string -> string *) val compare : t -> t -> int (** Alias for {!String.compare} *) external unsafe_get : string -> int -> char = "%string_unsafe_get" (** Alias for {!String.unsafe_get} *) end stdcompat-10/stdcompat__stubs.c.in000066400000000000000000000004101350471256400174220ustar00rootroot00000000000000#include #include @C_BEGIN_BEFORE_4_05_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_05_0@ stdcompat-10/stdcompat__sys.ml.in000066400000000000000000000023211350471256400172710ustar00rootroot00000000000000include Sys @BEGIN_BEFORE_4_08_0@ let max_floatarray_length = max_array_length / (64 / word_size) @END_BEFORE_4_08_0@ @BEGIN_BEFORE_4_05_0@ let getenv_opt var = Stdcompat__tools.option_find getenv var @END_BEFORE_4_05_0@ @BEGIN_BEFORE_4_04_0@ type backend_type = | Native | Bytecode | Other of string let backend_type = if Stdcompat__native.native then Native else Bytecode @END_BEFORE_4_04_0@ @BEGIN_BEFORE_4_03_0@ let sigbus = -22 let sigpoll = -23 let sigsys = -24 let sigtrap = -25 let sigurg = -26 let sigxcpu = -27 let sigxfsz = -28 let int_size = if 1 lsl word_size = 0 then word_size else if 1 lsl (word_size - 1) = 0 then word_size - 1 else assert false let big_endian = @BIG_ENDIAN@ let runtime_variant () = "" let runtime_parameters () = "" let enable_runtime_warnings _ = () let runtime_warnings_enabled () = false let opaque_identity x = x @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_01_0@ let unix = os_type = "Unix" let win32 = os_type = "Win32" let cygwin = os_type = "Cygwin" @END_BEFORE_4_01_0@ @BEGIN_BEFORE_3_10_0@ let is_directory path = try ignore (readdir path); true with Sys_error _ when file_exists path -> false @END_BEFORE_3_10_0@ stdcompat-10/stdcompat__sys.mli.in000066400000000000000000000000331350471256400174400ustar00rootroot00000000000000include Stdcompat__sys_s.S stdcompat-10/stdcompat__sys_s.mli.in000066400000000000000000000204571350471256400177760ustar00rootroot00000000000000module 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} *) 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" *) val argv : string array (** Alias for {!Sys.argv} *) val executable_name : string (** Alias for {!Sys.executable_name} *) @BEGIN_FROM_3_08_0@ external file_exists : string -> bool = "caml_sys_file_exists" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external file_exists : string -> bool = "sys_file_exists" @END_BEFORE_3_08_0@ (** @since 3.08.0: external file_exists : string -> bool = "caml_sys_file_exists" @since 3.07.0: external file_exists : string -> bool = "sys_file_exists" *) @BEGIN_FROM_3_08_0@ external remove : string -> unit = "caml_sys_remove" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external remove : string -> unit = "sys_remove" @END_BEFORE_3_08_0@ (** @since 3.08.0: external remove : string -> unit = "caml_sys_remove" @since 3.07.0: external remove : string -> unit = "sys_remove" *) @BEGIN_FROM_3_08_0@ external rename : string -> string -> unit = "caml_sys_rename" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external rename : string -> string -> unit = "sys_rename" @END_BEFORE_3_08_0@ (** @since 3.08.0: external rename : string -> string -> unit = "caml_sys_rename" @since 3.07.0: external rename : string -> string -> unit = "sys_rename" *) @BEGIN_FROM_3_08_0@ external getenv : string -> string = "caml_sys_getenv" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external getenv : string -> string = "sys_getenv" @END_BEFORE_3_08_0@ (** @since 3.08.0: external getenv : string -> string = "caml_sys_getenv" @since 3.07.0: external getenv : string -> string = "sys_getenv" *) @BEGIN_FROM_3_08_0@ external command : string -> int = "caml_sys_system_command" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external command : string -> int = "sys_system_command" @END_BEFORE_3_08_0@ (** @since 3.08.0: external command : string -> int = "caml_sys_system_command" @since 3.07.0: external command : string -> int = "sys_system_command" *) @BEGIN_FROM_4_03_0@ external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_FROM_3_08_0@ external time : unit -> float = "caml_sys_time" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external time : unit -> float = "sys_time" @END_BEFORE_3_08_0@ @END_BEFORE_4_03_0@ (** @since 4.03.0: external time : unit -> ((float)[@unboxed ]) = "caml_sys_time" "caml_sys_time_unboxed" [@@noalloc ] @since 3.08.0: external time : unit -> float = "caml_sys_time" @since 3.07.0: external time : unit -> float = "sys_time" *) @BEGIN_FROM_3_08_0@ external chdir : string -> unit = "caml_sys_chdir" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external chdir : string -> unit = "sys_chdir" @END_BEFORE_3_08_0@ (** @since 3.08.0: external chdir : string -> unit = "caml_sys_chdir" @since 3.07.0: external chdir : string -> unit = "sys_chdir" *) @BEGIN_FROM_3_08_0@ external getcwd : unit -> string = "caml_sys_getcwd" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external getcwd : unit -> string = "sys_getcwd" @END_BEFORE_3_08_0@ (** @since 3.08.0: external getcwd : unit -> string = "caml_sys_getcwd" @since 3.07.0: external getcwd : unit -> string = "sys_getcwd" *) @BEGIN_FROM_3_08_0@ external readdir : string -> string array = "caml_sys_read_directory" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external readdir : string -> string array = "sys_read_directory" @END_BEFORE_3_08_0@ (** @since 3.08.0: external readdir : string -> string array = "caml_sys_read_directory" @since 3.07.0: external readdir : string -> string array = "sys_read_directory" *) val interactive : bool ref (** Alias for {!Sys.interactive} *) val os_type : string (** Alias for {!Sys.os_type} *) val word_size : int (** Alias for {!Sys.word_size} *) val max_string_length : int (** Alias for {!Sys.max_string_length} *) val max_array_length : int (** Alias for {!Sys.max_array_length} *) @BEGIN_FROM_3_08_0@ external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" @END_FROM_3_08_0@ @BEGIN_BEFORE_3_08_0@ external signal : int -> signal_behavior -> signal_behavior = "install_signal_handler" @END_BEFORE_3_08_0@ (** @since 3.08.0: external signal : int -> signal_behavior -> signal_behavior = "caml_install_signal_handler" @since 3.07.0: external signal : int -> signal_behavior -> signal_behavior = "install_signal_handler" *) val set_signal : int -> signal_behavior -> unit (** Alias for {!Sys.set_signal} *) val sigabrt : int (** Alias for {!Sys.sigabrt} *) val sigalrm : int (** Alias for {!Sys.sigalrm} *) val sigfpe : int (** Alias for {!Sys.sigfpe} *) val sighup : int (** Alias for {!Sys.sighup} *) val sigill : int (** Alias for {!Sys.sigill} *) val sigint : int (** Alias for {!Sys.sigint} *) val sigkill : int (** Alias for {!Sys.sigkill} *) val sigpipe : int (** Alias for {!Sys.sigpipe} *) val sigquit : int (** Alias for {!Sys.sigquit} *) val sigsegv : int (** Alias for {!Sys.sigsegv} *) val sigterm : int (** Alias for {!Sys.sigterm} *) val sigusr1 : int (** Alias for {!Sys.sigusr1} *) val sigusr2 : int (** Alias for {!Sys.sigusr2} *) val sigchld : int (** Alias for {!Sys.sigchld} *) val sigcont : int (** Alias for {!Sys.sigcont} *) val sigstop : int (** Alias for {!Sys.sigstop} *) val sigtstp : int (** Alias for {!Sys.sigtstp} *) val sigttin : int (** Alias for {!Sys.sigttin} *) val sigttou : int (** Alias for {!Sys.sigttou} *) val sigvtalrm : int (** Alias for {!Sys.sigvtalrm} *) val sigprof : int (** Alias for {!Sys.sigprof} *) val catch_break : bool -> unit (** Alias for {!Sys.catch_break} *) val ocaml_version : string (** Alias for {!Sys.ocaml_version} *) end stdcompat-10/stdcompat__tools.ml.in000066400000000000000000000021361350471256400176170ustar00rootroot00000000000000@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-10/stdcompat__tools.mli.in000066400000000000000000000011401350471256400177620ustar00rootroot00000000000000@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-10/stdcompat__uchar.ml.in000066400000000000000000000021611350471256400175570ustar00rootroot00000000000000@BEGIN_FROM_4_03_0@ include Uchar @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_UCHAR_PKG@ include Uchar @END_WITH_UCHAR_PKG@ @BEGIN_WITHOUT_UCHAR_PKG@ type t = int let min = 0 let max = 0x10FFFF let lo_bound = 0xD7FF let hi_bound = 0xE000 let succ u = if u = lo_bound then hi_bound else if u = max then invalid_arg "Uchar.succ" else succ u let pred u = if u = hi_bound then lo_bound else if u = min then invalid_arg "Uchar.pred" else pred u let is_valid i = min <= i && i <= lo_bound || hi_bound <= i && i <= max let of_int i = if is_valid i then i else invalid_arg "Uchar.of_int" let unsafe_of_int i = i let to_int i = i let is_char u = u < 0x100 let of_char c = Char.code c let to_char u = if is_char u then Char.unsafe_chr u else invalid_arg "Uchar.to_char" let unsafe_to_char u = Char.unsafe_chr u let equal : t -> t -> bool = ( = ) let compare : t -> t -> int = compare let hash = to_int @END_WITHOUT_UCHAR_PKG@ @END_BEFORE_4_03_0@ @BEGIN_BEFORE_4_06_0@ let bom = unsafe_of_int 0xFEFF let rep = unsafe_of_int 0xFFFD @END_BEFORE_4_06_0@ stdcompat-10/stdcompat__uchar.mli.in000066400000000000000000000000351350471256400177260ustar00rootroot00000000000000include Stdcompat__uchar_s.S stdcompat-10/stdcompat__uchar_s.mli.in000066400000000000000000000025521350471256400202560ustar00rootroot00000000000000module type S = sig @BEGIN_FROM_4_03_0@ type t = Uchar.t @END_FROM_4_03_0@ @BEGIN_BEFORE_4_03_0@ @BEGIN_WITH_UCHAR_PKG@ type t = Uchar.t @END_WITH_UCHAR_PKG@ @BEGIN_WITHOUT_UCHAR_PKG@ type t @END_WITHOUT_UCHAR_PKG@ @END_BEFORE_4_03_0@ (** @since 4.03.0: type t *) val bom : t (** @since 4.06.0: val bom : t *) val rep : t (** @since 4.06.0: val rep : t *) val min : t (** @since 4.03.0: val min : t *) val max : t (** @since 4.03.0: val max : t *) val succ : t -> t (** @since 4.03.0: val succ : t -> t *) val pred : t -> t (** @since 4.03.0: val pred : t -> t *) val is_valid : int -> bool (** @since 4.03.0: val is_valid : int -> bool *) val of_int : int -> t (** @since 4.03.0: val of_int : int -> t *) val unsafe_of_int : int -> t (** @since 4.03.0: val unsafe_of_int : int -> t *) val to_int : t -> int (** @since 4.03.0: val to_int : t -> int *) val is_char : t -> bool (** @since 4.03.0: val is_char : t -> bool *) val of_char : char -> t (** @since 4.03.0: val of_char : char -> t *) val to_char : t -> char (** @since 4.03.0: val to_char : t -> char *) val unsafe_to_char : t -> char (** @since 4.03.0: val unsafe_to_char : t -> char *) val equal : t -> t -> bool (** @since 4.03.0: val equal : t -> t -> bool *) val compare : t -> t -> int (** @since 4.03.0: val compare : t -> t -> int *) val hash : t -> int (** @since 4.03.0: val hash : t -> int *) end stdcompat-10/stdcompat__weak.ml.in000066400000000000000000000017241350471256400174100ustar00rootroot00000000000000type '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-10/stdcompat__weak.mli.in000066400000000000000000000000341350471256400175520ustar00rootroot00000000000000include Stdcompat__weak_s.S stdcompat-10/stdcompat__weak_s.mli.in000066400000000000000000000061211350471256400200770ustar00rootroot00000000000000module type S = sig type 'a t = 'a Weak.t (** Alias for {!Weak.t} *) @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 -> 'a -> 'a) -> t -> 'a -> 'a val count : t -> int val stats : t -> (int * int * int * int * int * int) end @END_BEFORE_4_05_0@ (** @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 -> 'a -> 'a) -> t -> 'a -> 'a 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-10/stdcompat_tests.ml.in000066400000000000000000000435511350471256400174700ustar00rootroot00000000000000let () = 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); 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); 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 (Stdcompat.List.assq_opt "a" ["a", 1; "b", 2; "c", 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"); 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 (not (Stdcompat.Array.memq "a" [| "a"; "b"; "c" |])); 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); 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 f (); 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); () stdcompat-10/test_all_switches.sh000077500000000000000000000004031350471256400173550ustar00rootroot00000000000000#!/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