Kxclib (kxclib.Kxclib)

val refset : 'a Stdlib.ref -> 'b -> unit

refset r x sets x to ref r.

val refget : 'a Stdlib.ref -> 'b

refget r returns !r.

val refupdate : 'a Stdlib.ref -> ('b -> 'c) -> unit

refupdate r f updates referent of r by f.

val refupdate_and_calc : 'x Stdlib.ref -> ('x -> 'a * 'x) -> 'a

refupdate_and_calc r f calculate a result and the a updated referent value from the current referent value of r using f.

val refappend : 'a list Stdlib.ref -> 'b -> unit

refappend r x appends x to referent of r.

val refupdate' : ('a -> 'b) -> 'c Stdlib.ref -> unit

refupdate' f r is equivalent to refupdate r f.

val refappend' : 'a -> 'b list Stdlib.ref -> unit

refappend' x r is equivalent to refappend r x.

val refpop : 'a list Stdlib.ref -> 'b

refpop r pop first item of the list referred to by r. Raises Not_found if the list is empty.

val incr : int Stdlib.ref -> unit

incr r increases the referent of r by one.

val decr : int Stdlib.ref -> unit

decr r decreases the referent of r by one.

val refupdate'_and_get : ('a -> 'b) -> 'c Stdlib.ref -> 'd

val get_and_refupdate' : ('a -> 'b) -> 'c Stdlib.ref -> 'd

val incr_and_get : int Stdlib.ref -> int

val decr_and_get : int Stdlib.ref -> int

val get_and_incr : int Stdlib.ref -> int

val get_and_decr : int Stdlib.ref -> int

val constant : 'a -> 'b -> 'c

constant function

val identity : 'a -> 'b

identity function

val failwith' : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'c

val invalid_arg' : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'c

val iotaf : (int -> 'a) -> int -> 'b list

val iotaf' : (int -> unit) -> int -> unit

val iotafl : ('a -> int -> 'b) -> 'c -> int -> 'd

val iotafl' : ('a -> 'b -> 'c) -> 'd -> (int -> 'e) -> int -> 'f

val min_by : ('a -> 'b) -> 'c -> 'd -> 'e

val max_by : ('a -> 'b) -> 'c -> 'd -> 'e

val dup : 'x -> 'x * 'x

val swap : ('x * 'y) -> 'y * 'x

type null = |

module Functionals : sig ... end

module Fn = Functionals

include module type of struct include Functionals.BasicInfix end

val (&) : ('x -> 'y) -> 'x -> 'y

function application; reverse of (|>), same as (@@)

val (%) : ('y -> 'z) -> ('x -> 'y) -> 'x -> 'z

function composition 1

val (%%) : ('a -> 'y -> 'z) -> ('x -> 'y) -> 'a -> 'x -> 'z

function composition 1, on second argument

val (&>) : ('x -> 'y) -> ('y -> 'z) -> 'x -> 'z

function composition 2

val (?.) : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c

val (?..) : ('a -> 'b -> 'c -> 'd) -> 'c -> 'a -> 'b -> 'd

val (!.) : 'b -> ('b0 -> 'b -> 'c) -> 'b -> 'c

val (!..) : 'c -> ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'd

val (&&>) : ('x -> 'y -> 'z) -> ('z -> 'r) -> 'x -> 'y -> 'r

function composition 2, arity=2

val (|->) : 'x -> ('x -> unit) -> 'x

piping with tapping

val (//) : ('a -> 'x) -> ('b -> 'y) -> ('a * 'b) -> 'x * 'y

val (/>) : ('a * 'b) -> ('b -> 'c) -> 'a * 'c

piping calc on snd

val (/<) : ('a * 'b) -> ('a -> 'c) -> 'c * 'b

piping calc on fst

val (|+>) : 'a -> ('a -> 'b) -> 'a * 'b

piping calc to snd

val (|+<) : 'a -> ('a -> 'b) -> 'b * 'a

piping calc to fst

val (?>) : ('b -> 'c) -> ('a * 'b) -> 'a * 'c

lift to snd

val (?<) : ('a -> 'c) -> ('a * 'b) -> 'c * 'b

lift to fst

val (?+>) : ('a -> 'b) -> 'a -> 'a * 'b

calculate to snd

val (?+<) : ('a -> 'b) -> 'a -> 'b * 'a

calculate to fst

val (?&>) : ('y2 -> 'x2) -> (('x1 * 'x2) -> 'r) -> ('x1 * 'y2) -> 'r

lift to map snd

val (?&<) : ('y1 -> 'x1) -> (('x1 * 'x2) -> 'r) -> ('y1 * 'x2) -> 'r

lift to map fst

val (!!) : ('a -> 'b -> 'x) -> ('a * 'b) -> 'x

uncurry

val (!?) : (('a * 'b) -> 'x) -> 'a -> 'b -> 'x

curry

include module type of struct include Functionals.CommonTypes end

type 'x endo = 'x -> 'x

module PipeOps (S : sig ... end) : sig ... end

module PipeOps_flat_map (S : sig ... end) : sig ... end

module type Monadic = sig ... end

module type MonadOpsS = sig ... end

module MonadOps (M : sig ... end) : MonadOpsS with type 'x t := 'x M.t

val foldl : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a

List.fold_right

val foldr : ('a -> 'b -> 'b) -> 'c -> 'a list -> 'd

List.fold_left but arg pos exchanged

val projected_compare : ('a -> 'b) -> 'c -> 'd -> int

val neg : int -> int

val mul : int -> int -> int

val div : int -> int -> int

val rem : int -> int -> int

module Either : sig ... end

type ('a, 'b) either = ('a, 'b) Either.t

module Result : sig ... end

module type ResultOfS = sig ... end

module ResultOf (E : sig ... end) : ResultOfS with type err = E.err

module type ResultOfS' = sig ... end

module ResultOf' (E : sig ... end) : ResultOfS' with type err = E.err

module ResultWithErrmsg0 : sig ... end

module Queue : sig ... end

type 'x queue = 'x Queue.t

module Option0 : sig ... end

module Option : sig ... end

val some : 'a -> 'a option

val none : 'a option

val (>?) : 'a option -> ('a -> 'b) -> 'b option

val (>>?) : 'a option -> ('a -> 'b option) -> 'b option

val (|?) : 'a Option.t -> 'b -> 'c

val (|?!) : 'a Option.t -> (unit -> 'a) -> 'b

val (||?) : 'a Option.t -> 'a Option.t -> 'a Option.t

val (||?!) : 'a Option.t -> (unit -> 'a Option.t) -> 'a Option.t

val (&>?) : ('x -> 'y option) -> ('y -> 'z) -> 'x -> 'z option

val (&>>?) : ('x -> 'y option) -> ('y -> 'z option) -> 'x -> 'z option

module Seq0 : sig ... end

module Seq : sig ... end

type 'x seq = 'x Seq.t

module Array0 : sig ... end

module Array : sig ... end

module List0 : sig ... end

module List : sig ... end

include module type of struct include List.Ops_piping end

val (|&>) : 'x Stdlib.List.t -> ('x -> 'y) -> 'y Stdlib.List.t

val (|&>>) : 'x Stdlib.List.t -> ('x -> 'y Stdlib.List.t) -> 'y Stdlib.List.t

val (|+&>) : 'x Stdlib.List.t -> ('x -> 'y) -> ('x * 'y) Stdlib.List.t

val (|!>) : 'x Stdlib.List.t -> ('x -> unit) -> unit

val (|-!>) : 'x Stdlib.List.t -> ('x -> unit) -> 'x Stdlib.List.t

val (|@>) : 'x Stdlib.List.t -> ('acc * (('acc * 'x) -> 'acc)) -> 'acc

val (|?>) : 'x Stdlib.List.t -> ('x -> bool) -> 'x Stdlib.List.t

val (|&?>) : 'x Stdlib.List.t -> ('x -> 'y option) -> 'y Stdlib.List.t

val (|+&?>) : 'x Stdlib.List.t -> ('x -> 'y option) -> ('x * 'y) Stdlib.List.t

val iota : int -> int List.t

val iota1 : int -> int List.t

module Hashtbl : sig ... end

module Bytes : sig ... end

module String : sig ... end

module MapPlus (M : Stdlib.Map.S) : sig ... end

module StringMap : sig ... end

module IntMap : sig ... end

module Obj : sig ... end

module IoPervasives : sig ... end

include module type of struct include IoPervasives end

val with_input_file : string -> (Stdlib.in_channel -> 'a) -> 'b

val with_output_file : string -> (Stdlib.out_channel -> 'a) -> 'b

val slurp_input : ?buf:bytes -> Stdlib.in_channel -> string

val slurp_stdin : ?buf:bytes -> unit -> string

val slurp_file : string -> string

val spit_file : string -> string -> unit

module Timing : sig ... end

module Int53p : sig ... end

include module type of struct include Int53p.Ops end

type int53p = Int53p.Internals.CurrentFlavorImpl.Ops.int53p

val (~-%) : int53p -> int53p

val (~+%) : int53p -> int53p

val (+%) : int53p -> int53p -> int53p

val (-%) : int53p -> int53p -> int53p

val (*%) : int53p -> int53p -> int53p

val (/%) : int53p -> int53p -> int53p

val (/%%) : int53p -> int53p -> int53p

module Datetime0 : sig ... end

all according to proleptic Gregorian Calender

module ParseArgs : sig ... end

module ArgOptions : sig ... end

module FmtPervasives : sig ... end

include module type of struct include FmtPervasives end

type ppf = Stdlib.Format.formatter

val color_enabled : bool Stdlib.ref

val fprintf : 
  Stdlib.Format.formatter ->
  ('a, Stdlib.Format.formatter, unit) Stdlib.format ->
  'b

val printf : ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'b

val sprintf : ('a, Stdlib.Format.formatter, unit, string) Stdlib.format4 -> 'b

val eprintf : ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'b

module Fmt = FmtPervasives.Fmt

val condformat : 
  bool ->
  (('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'b) ->
  ('a, Stdlib.Format.formatter, unit) Stdlib.format ->
  'c

val pp_of_to_string : ('a -> string) -> Stdlib.Format.formatter -> 'b -> unit

val to_string_of_pp : (Stdlib.Format.formatter -> 'a -> unit) -> 'a -> string

val pps : ('a -> string) -> Stdlib.Format.formatter -> 'a -> unit

val spp : (Stdlib.Format.formatter -> 'a -> unit) -> 'a -> string

val pp_int : Stdlib.Format.formatter -> int -> unit

val pp_float : Stdlib.Format.formatter -> float -> unit

val pp_string : Stdlib.Format.formatter -> string -> unit

val pp_string_quoted : Stdlib.Format.formatter -> string -> unit

val pp_char : Stdlib.Format.formatter -> char -> unit

val pp_bool : Stdlib.Format.formatter -> bool -> unit

val pp_unit : Stdlib.Format.formatter -> unit -> unit

val pp_ref_address : Stdlib.Format.formatter -> 'x Stdlib.ref -> unit

val pp_int32 : Stdlib.Format.formatter -> int32 -> unit

val pp_int64 : Stdlib.Format.formatter -> int64 -> unit

val pp_integer_sep' : 
  padding:(int * char) option ->
  Stdlib.Format.formatter ->
  int ->
  unit

print integer with thousand separator

val pp_integer_sep : Stdlib.Format.formatter -> int -> unit

val pp_multiline : Stdlib.Format.formatter -> string -> unit

val pp_exn : Stdlib.Format.formatter -> exn -> unit

val pp_full_exn' : 
  Stdlib.Format.formatter ->
  (exn * Stdlib.Printexc.raw_backtrace) ->
  unit

val pp_full_exn : Stdlib.Format.formatter -> exn -> unit

val string_of_symbolic_output_items : 
  Stdlib.Format.symbolic_output_item list ->
  string

module Log0 : sig ... end

include module type of struct include Log0.Pervasives end

val debug : 
  ?modul:string ->
  ('a, Stdlib.Format.formatter, unit, unit) Stdlib.format4 ->
  'b

val info : 
  ?modul:string ->
  ('a, Stdlib.Format.formatter, unit, unit) Stdlib.format4 ->
  'b

module Runtime_info : sig ... end

type backtrace_info = [

| `ocaml_backtrace of Stdlib.Printexc.raw_backtrace
| `string_stacktrace of string

]

module Backtrace_info : sig ... end

module type Io_style = sig ... end

exceptions thrown in executing second argument of bind is expected to be caught and could be retrieved using extract_error

module Direct_io : sig ... end

module CheckDirectIo : Io_style

exceptions thrown in executing second argument of bind is expected to be caught and could be retrieved using extract_error

module Json : sig ... end

module Jv : sig ... end

module Base64 : sig ... end

module Url_encoding : sig ... end

encode / decode a string according to the RFC 3986 Section 2.1 URI Generic Syntax - Percent-Encoding syntax