package hardcaml_waveterm

You can search for identifiers within the package.

in-package search v0.2.0

hardcaml_waveterm
- Hardcaml_waveterm
  - Data
  - Display_rules
    
    Rule
  - Draw
    
    In_memory
    
    Make
    
    B
    
    Primitives
    
    S
    
    Style
  - Import
    
    Bits
  - Port
    
    Type
  - Port_name
  - Render
    
    Bounds
    
    Make
    
    G
    
    Static
    
    R
    
    Styles
  - Sim
  - Wave
  - Wave_format
  - Waveform
  - Waves
    
    Config
  - Write
hardcaml_waveterm.interactive
- Hardcaml_waveterm_interactive
  - Draw_notty
  - Scroll
    
    Adjustment
    
    HScrollbar
    
    Mouse_mode
    
    Orientation
    
    Scroll_bar_mode
    
    Scroll_bar_style
    
    Scrollable
    
    Scrollbar
    
    VScrollbar
  - Widget

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Base end

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 Int32 = Base.Int32

module Int63 = Base.Int63

module Int64 = Base.Int64

module Intable = Base.Intable

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 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 = Base.Polymorphic_compare

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 module type of struct include T end

module type T = Base.T

module type T1 = Base.T1

module type T2 = Base.T2

module type T3 = Base.T3

module Sexp = Base.Sexp

module Export = Base.Export

include module type of struct include Export end

type 'a array = 'a Base.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. (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a array

val sexp_of_array : 'a. ('a -> Base.Sexp.t) -> 'a array -> Base.Sexp.t

type bool = Base.Bool.t

val compare_bool : bool -> bool -> int

val equal_bool : bool -> bool -> bool

val hash_fold_bool : Base.Hash.state -> bool -> Base.Hash.state

val hash_bool : bool -> Base.Hash.hash_value

val bool_of_sexp : Base.Sexp.t -> bool

val sexp_of_bool : bool -> Base.Sexp.t

type char = Base.Char.t

val compare_char : char -> char -> int

val equal_char : char -> char -> bool

val hash_fold_char : Base.Hash.state -> char -> Base.Hash.state

val hash_char : char -> Base.Hash.hash_value

val char_of_sexp : Base.Sexp.t -> char

val sexp_of_char : char -> Base.Sexp.t

type exn = Base.Exn.t

val sexp_of_exn : exn -> Base.Sexp.t

type float = Base.Float.t

val compare_float : float -> float -> int

val equal_float : float -> float -> bool

val hash_fold_float : Base.Hash.state -> float -> Base.Hash.state

val hash_float : float -> Base.Hash.hash_value

val float_of_sexp : Base.Sexp.t -> float

val sexp_of_float : float -> Base.Sexp.t

type int = Base.Int.t

val compare_int : int -> int -> int

val equal_int : int -> int -> bool

val hash_fold_int : Base.Hash.state -> int -> Base.Hash.state

val hash_int : int -> Base.Hash.hash_value

val int_of_sexp : Base.Sexp.t -> int

val sexp_of_int : int -> Base.Sexp.t

type int32 = Base.Int32.t

val compare_int32 : int32 -> int32 -> int

val equal_int32 : int32 -> int32 -> bool

val hash_fold_int32 : Base.Hash.state -> int32 -> Base.Hash.state

val hash_int32 : int32 -> Base.Hash.hash_value

val int32_of_sexp : Base.Sexp.t -> int32

val sexp_of_int32 : int32 -> Base.Sexp.t

type int64 = Base.Int64.t

val compare_int64 : int64 -> int64 -> int

val equal_int64 : int64 -> int64 -> bool

val hash_fold_int64 : Base.Hash.state -> int64 -> Base.Hash.state

val hash_int64 : int64 -> Base.Hash.hash_value

val int64_of_sexp : Base.Sexp.t -> int64

val sexp_of_int64 : int64 -> Base.Sexp.t

type 'a list = 'a Base.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. (Base.Hash.state -> 'a -> Base.Hash.state) ->
  Base.Hash.state ->
  'a list ->
  Base.Hash.state

val list_of_sexp : 'a. (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a list

val sexp_of_list : 'a. ('a -> Base.Sexp.t) -> 'a list -> Base.Sexp.t

type nativeint = Base.Nativeint.t

val compare_nativeint : nativeint -> nativeint -> int

val equal_nativeint : nativeint -> nativeint -> bool

val hash_fold_nativeint : Base.Hash.state -> nativeint -> Base.Hash.state

val hash_nativeint : nativeint -> Base.Hash.hash_value

val nativeint_of_sexp : Base.Sexp.t -> nativeint

val sexp_of_nativeint : nativeint -> Base.Sexp.t

type 'a option = 'a Base.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. (Base.Hash.state -> 'a -> Base.Hash.state) ->
  Base.Hash.state ->
  'a option ->
  Base.Hash.state

val option_of_sexp : 'a. (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a option

val sexp_of_option : 'a. ('a -> Base.Sexp.t) -> 'a option -> Base.Sexp.t

type 'a ref = 'a Base.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. (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a ref

val sexp_of_ref : 'a. ('a -> Base.Sexp.t) -> 'a ref -> Base.Sexp.t

type string = Base.String.t

val compare_string : string -> string -> int

val equal_string : string -> string -> bool

val hash_fold_string : Base.Hash.state -> string -> Base.Hash.state

val hash_string : string -> Base.Hash.hash_value

val string_of_sexp : Base.Sexp.t -> string

val sexp_of_string : string -> Base.Sexp.t

type bytes = Base.Bytes.t

val compare_bytes : bytes -> bytes -> int

val equal_bytes : bytes -> bytes -> bool

val bytes_of_sexp : Base.Sexp.t -> bytes

val sexp_of_bytes : bytes -> Base.Sexp.t

type unit = Base.Unit.t

val compare_unit : unit -> unit -> int

val equal_unit : unit -> unit -> bool

val hash_fold_unit : Base.Hash.state -> unit -> Base.Hash.state

val hash_unit : unit -> Base.Hash.hash_value

val unit_of_sexp : Base.Sexp.t -> unit

val sexp_of_unit : unit -> Base.Sexp.t

Format stuff

type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) format

type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) format4

type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) 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

List operators

include module type of struct include Base.List.Infix end

val (@) : 'a Base.List.t -> 'a Base.List.t -> 'a Base.List.t

Int operators and comparisons

include module type of struct include Base.Int.O end

A sub-module designed to be opened to make working with ints more convenient.

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

include Base.Comparisons.Infix with type t := Base.Int.t

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

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 ascending : int -> int -> int

val descending : int -> int -> int

val compare : int -> int -> int

val equal : int -> int -> bool

val max : int -> int -> int

val min : int -> int -> int

Float operators

include module type of struct include Base.Float.O_dot end

Similar to O, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

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)).

Boolean operations

val (&&) : bool -> bool -> bool

val (||) : bool -> bool -> bool

val not : bool -> bool

val ignore : _ -> unit

val (^) : Base.String.t -> Base.String.t -> Base.String.t

Common string operations

Reference operations

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

val ref : 'a -> 'a ref

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

Pair operations

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

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

Exceptions stuff

val raise : exn -> _

val failwith : string -> 'a

val invalid_arg : string -> 'a

val raise_s : Base.Sexp.t -> 'a

Misc

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

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

module Continue_or_stop = Base.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 Not_exposed_properly = Base.Not_exposed_properly

module Bits : sig ... end

module Cyclesim = Hardcaml.Cyclesim

module Out_channel = Stdio.Out_channel

module In_channel = Stdio.In_channel