Module `Hardcaml_waveterm__.Import`

module Applicative = Base.Applicative

module Array = Base.Array

module Avltree = Base.Avltree

module Backtrace = Base.Backtrace

module Binary_search = Base.Binary_search

module Binary_searchable = Base.Binary_searchable

module Blit = Base.Blit

module Bool = Base.Bool

module Buffer = Base.Buffer

module Bytes = Base.Bytes

module Char = Base.Char

module Comparable = Base.Comparable

module Comparator = Base.Comparator

module Comparisons = Base.Comparisons

module Container = Base.Container

module Either = Base.Either

module Equal = Base.Equal

module Error = Base.Error

module Exn = Base.Exn

module Field = Base.Field

module Float = Base.Float

module Floatable = Base.Floatable

module Fn = Base.Fn

module Formatter = Base.Formatter

module Hash = Base.Hash

module Hash_set = Base.Hash_set

module Hashable = Base.Hashable

module Hasher = Base.Hasher

module Hashtbl = Base.Hashtbl

module Identifiable = Base.Identifiable

module Indexed_container = Base.Indexed_container

module Info = Base.Info

module Int = Base.Int

module Int_conversions = Base.Int_conversions

module Int32 = Base.Int32

module Int63 = Base.Int63

module Int64 = Base.Int64

module Intable = Base.Intable

module Int_math = Base.Int_math

module Invariant = Base.Invariant

module Lazy = Base.Lazy

module List = Base.List

module Map = Base.Map

module Maybe_bound = Base.Maybe_bound

module Monad = Base.Monad

module Nativeint = Base.Nativeint

module Nothing = Base.Nothing

module Option = Base.Option

module Option_array = Base.Option_array

module Or_error = Base.Or_error

module Ordered_collection_common = Base.Ordered_collection_common

module Ordering = Base.Ordering

module Poly = Base.Poly

module Polymorphic_compare = Poly

module Popcount = Base.Popcount

module Pretty_printer = Base.Pretty_printer

module Printf = Base.Printf

module Linked_queue = Base.Linked_queue

module Queue = Base.Queue

module Random = Base.Random

module Ref = Base.Ref

module Result = Base.Result

module Sequence = Base.Sequence

module Set = Base.Set

module Sexpable = Base.Sexpable

module Sign = Base.Sign

module Sign_or_nan = Base.Sign_or_nan

module Source_code_position = Base.Source_code_position

module Stack = Base.Stack

module Staged = Base.Staged

module String = Base.String

module Stringable = Base.Stringable

module Sys = Base.Sys

module T = Base.T

module Type_equal = Base.Type_equal

module Uniform_array = Base.Uniform_array

module Unit = Base.Unit

module Uchar = Base.Uchar

module Validate = Base.Validate

module Variant = Base.Variant

module With_return = Base.With_return

module Word_size = Base.Word_size

include T

module type T = sig ... end

module type T1 = sig ... end

module type T2 = sig ... end

module type T3 = sig ... end

module Sexp = Base.Sexp

module Export = Base.Export

include Export

include Sexp.Private.Raw_grammar.Builtin

val unit_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val bool_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val string_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val bytes_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val char_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val int_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val float_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val int32_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val int64_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val nativeint_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val ref_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val lazy_t_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val option_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val list_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val array_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t

type 'a array = 'a Array.t

val compare_array : a. ('a -> 'a -> int) -> 'a array -> 'a array -> int
val equal_array : a. ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
val array_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a array
val sexp_of_array : a. ('a -> Sexp.t) -> 'a array -> Sexp.t
val array_sexp_grammar : Sexp.Private.Raw_grammar.t

type bool = Bool.t

val compare_bool : bool -> bool -> int
val equal_bool : bool -> bool -> bool
val hash_fold_bool : Hash.state -> bool -> Hash.state
val hash_bool : bool -> Hash.hash_value
val bool_of_sexp : Sexp.t -> bool
val sexp_of_bool : bool -> Sexp.t
val bool_sexp_grammar : Sexp.Private.Raw_grammar.t

type char = Char.t

val compare_char : char -> char -> int
val equal_char : char -> char -> bool
val hash_fold_char : Hash.state -> char -> Hash.state
val hash_char : char -> Hash.hash_value
val char_of_sexp : Sexp.t -> char
val sexp_of_char : char -> Sexp.t
val char_sexp_grammar : Sexp.Private.Raw_grammar.t

type exn = Exn.t

val sexp_of_exn : exn -> Sexp.t

type float = Float.t

val compare_float : float -> float -> int
val equal_float : float -> float -> bool
val hash_fold_float : Hash.state -> float -> Hash.state
val hash_float : float -> Hash.hash_value
val float_of_sexp : Sexp.t -> float
val sexp_of_float : float -> Sexp.t
val float_sexp_grammar : Sexp.Private.Raw_grammar.t

type int = Int.t

val compare_int : int -> int -> int
val equal_int : int -> int -> bool
val hash_fold_int : Hash.state -> int -> Hash.state
val hash_int : int -> Hash.hash_value
val int_of_sexp : Sexp.t -> int
val sexp_of_int : int -> Sexp.t
val int_sexp_grammar : Sexp.Private.Raw_grammar.t

type int32 = Int32.t

val compare_int32 : int32 -> int32 -> int
val equal_int32 : int32 -> int32 -> bool
val hash_fold_int32 : Hash.state -> int32 -> Hash.state
val hash_int32 : int32 -> Hash.hash_value
val int32_of_sexp : Sexp.t -> int32
val sexp_of_int32 : int32 -> Sexp.t
val int32_sexp_grammar : Sexp.Private.Raw_grammar.t

type int64 = Int64.t

val compare_int64 : int64 -> int64 -> int
val equal_int64 : int64 -> int64 -> bool
val hash_fold_int64 : Hash.state -> int64 -> Hash.state
val hash_int64 : int64 -> Hash.hash_value
val int64_of_sexp : Sexp.t -> int64
val sexp_of_int64 : int64 -> Sexp.t
val int64_sexp_grammar : Sexp.Private.Raw_grammar.t

type 'a list = 'a List.t

val compare_list : a. ('a -> 'a -> int) -> 'a list -> 'a list -> int
val equal_list : a. ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val hash_fold_list : a. (Hash.state -> 'a -> Hash.state) -> Hash.state -> 'a list -> Hash.state
val list_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a list
val sexp_of_list : a. ('a -> Sexp.t) -> 'a list -> Sexp.t
val list_sexp_grammar : Sexp.Private.Raw_grammar.t

type nativeint = Nativeint.t

val compare_nativeint : nativeint -> nativeint -> int
val equal_nativeint : nativeint -> nativeint -> bool
val hash_fold_nativeint : Hash.state -> nativeint -> Hash.state
val hash_nativeint : nativeint -> Hash.hash_value
val nativeint_of_sexp : Sexp.t -> nativeint
val sexp_of_nativeint : nativeint -> Sexp.t
val nativeint_sexp_grammar : Sexp.Private.Raw_grammar.t

type 'a option = 'a Option.t

val compare_option : a. ('a -> 'a -> int) -> 'a option -> 'a option -> int
val equal_option : a. ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
val hash_fold_option : a. (Hash.state -> 'a -> Hash.state) -> Hash.state -> 'a option -> Hash.state
val option_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a option
val sexp_of_option : a. ('a -> Sexp.t) -> 'a option -> Sexp.t
val option_sexp_grammar : Sexp.Private.Raw_grammar.t

type 'a ref = 'a Ref.t

val compare_ref : a. ('a -> 'a -> int) -> 'a ref -> 'a ref -> int
val equal_ref : a. ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool
val ref_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a ref
val sexp_of_ref : a. ('a -> Sexp.t) -> 'a ref -> Sexp.t
val ref_sexp_grammar : Sexp.Private.Raw_grammar.t

type string = String.t

val compare_string : string -> string -> int
val equal_string : string -> string -> bool
val hash_fold_string : Hash.state -> string -> Hash.state
val hash_string : string -> Hash.hash_value
val string_of_sexp : Sexp.t -> string
val sexp_of_string : string -> Sexp.t
val string_sexp_grammar : Sexp.Private.Raw_grammar.t

type bytes = Bytes.t

val compare_bytes : bytes -> bytes -> int
val equal_bytes : bytes -> bytes -> bool
val bytes_of_sexp : Sexp.t -> bytes
val sexp_of_bytes : bytes -> Sexp.t
val bytes_sexp_grammar : Sexp.Private.Raw_grammar.t

type unit = Unit.t

val compare_unit : unit -> unit -> int
val equal_unit : unit -> unit -> bool
val hash_fold_unit : Hash.state -> unit -> Hash.state
val hash_unit : unit -> Hash.hash_value
val unit_of_sexp : Sexp.t -> unit
val sexp_of_unit : unit -> Sexp.t
val unit_sexp_grammar : Sexp.Private.Raw_grammar.t

type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) Stdlib.format
type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Stdlib.format4
type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6

Sexp

Exporting the ad-hoc types that are recognized by ppx_sexp_* converters. sexp_array, sexp_list, and sexp_option allow a record field to be absent when converting from a sexp, and if absent, the field will take a default value of the appropriate type:

        sexp_array   [||]
        sexp_bool    false
        sexp_list    []
        sexp_option  None

sexp_opaque causes the conversion to sexp to produce the atom <opaque>.

For more documentation, see sexplib/README.md.

type 'a sexp_array = 'a array
type 'a sexp_list = 'a list
type 'a sexp_opaque = 'a
type 'a sexp_option = 'a option

include List.Infix

val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t

include Int.O

val (+) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (-) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (*) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (~-) : Base__Int.t -> Base__Int.t
val (**) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (>=) : Base__Int.t -> Base__Int.t -> bool
val (<=) : Base__Int.t -> Base__Int.t -> bool
val (=) : Base__Int.t -> Base__Int.t -> bool
val (>) : Base__Int.t -> Base__Int.t -> bool
val (<) : Base__Int.t -> Base__Int.t -> bool
val (<>) : Base__Int.t -> Base__Int.t -> bool
val abs : Base__Int.t -> Base__Int.t
val neg : Base__Int.t -> Base__Int.t
val zero : Base__Int.t
val (%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (//) : Base__Int.t -> Base__Int.t -> float
val (land) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lxor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lnot) : Base__Int.t -> Base__Int.t
val (lsl) : Base__Int.t -> int -> Base__Int.t
val (asr) : Base__Int.t -> int -> Base__Int.t
val (lsr) : Base__Int.t -> int -> Base__Int.t

include Base__.Import.Int_replace_polymorphic_compare

val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (<>) : int -> int -> bool
val (=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int

include Float.O_dot

val (+.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (-.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (*.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (/.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (**.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (~-.) : Base__Float.t -> Base__Float.t

val (|>) : 'a -> ('a -> 'b) -> 'b: Reverse application operator. x |> g |> f is equivalent to f (g (x)).

val (@@) : ('a -> 'b) -> 'a -> 'b: Application operator. g @@ f @@ x is equivalent to g (f (x)).

val (&&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val not : bool -> bool
val ignore : _ -> unit

val (^) : String.t -> String.t -> String.t: Common string operations

val (!) : 'a ref -> 'a
val ref : 'a -> 'a ref
val (:=) : 'a ref -> 'a -> unit

val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b

val raise : exn -> _

val failwith : string -> 'a
val invalid_arg : string -> 'a
val raise_s : Sexp.t -> 'a

val phys_equal : 'a -> 'a -> bool

val force : 'a Lazy.t -> 'a

module Continue_or_stop = Base__.Container_intf.Export.Continue_or_stop: Continue_or_stop.t is used by the f argument to fold_until in order to indicate whether folding should continue, or stop early.

exception Not_found_s of Sexplib0.Sexp.t

module Bits : sig ... end

module Cyclesim = Hardcaml.Cyclesim

module Out_channel = Stdio.Out_channel

module In_channel = Stdio.In_channel