Utils (hax-engine.Hax

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

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

val (&&&) : ('a -> 'b) -> ('a0 -> 'c) -> 'a1 -> 'b0 * 'c0

val (***) : ('a -> 'b) -> ('c -> 'd) -> ('a0 * 'c0) -> 'b0 * 'd0

val map_fst : ('a -> 'b) -> ('a * 'c) -> 'b * 'd

val map_snd : ('a -> 'b) -> ('c * 'a) -> 'd * 'b

val map_fst3 : ('a -> 'b) -> ('c * 'd * 'e) -> 'f * 'g * 'h

val map_snd3 : ('a -> 'b) -> ('c * 'd * 'e) -> 'f * 'g * 'h

val map_thd3 : ('a -> 'b) -> ('c * 'd * 'e) -> 'f * 'g * 'h

val fst3 : ('a * 'b * 'c) -> 'd

val snd3 : ('a * 'b * 'c) -> 'd

val thd3 : ('a * 'b * 'c) -> 'd

val curry : (('a * 'b) -> 'c) -> 'd -> 'e -> 'f

val uncurry : ('a -> 'b -> 'c) -> ('d * 'e) -> 'f

val curry3 : (('a * 'b * 'c) -> 'd) -> 'e -> 'f -> 'g -> 'h

val uncurry3 : ('a -> 'b -> 'c -> 'd) -> ('e * 'f * 'g) -> 'h

val tup2 : 'a -> 'b -> 'c * 'd

val swap : ('a * 'b) -> 'c * 'd

val apply : ('a -> 'b) -> 'c -> 'd

val let* : 'a Base.Option.t -> ('a -> 'b Base.Option.t) -> 'b Base.Option.t

val some_if_true : bool -> unit option

val let*? : Base.bool -> (Base.unit -> 'a Base.option) -> 'a0 Base.Option.t

let*? () = guard in body acts as a guard: if guard holds, then body is executed, otherwise None is returned.

val map_first_letter : 
  (Base.string -> Base.string) ->
  Base.string ->
  Base.String.t

val split_list_once : 
  equal:('a -> 'a -> bool) ->
  needle:'a Base.List.t ->
  acc:'b Base.List.t ->
  'a Base.List.t ->
  'c Base.List.t * 'd Base.List.t

val split_list : 
  equal:('a -> 'a -> bool) ->
  needle:'a Base.List.t ->
  'a0 Base.list ->
  'a1 Base.list Base.list

val first_letter : Base.String.t -> Base.String.t

val is_uppercase : Base.String.t -> bool

val is_lowercase : Base.String.t -> bool

val start_uppercase : Base.String.t -> bool

val start_lowercase : Base.String.t -> bool

val string_to_int : string -> Base.Int.t option

val split_str : Base.string -> on:Base.string -> Base.string Base.list

val last_init : 'a Base.list -> ('a0 Base.list * 'a0) Base.option

val inits : 'a Base.list -> ('a0 Base.list * 'a1) Base.list

val sequence : 'a Base.option Base.list -> 'a0 Base.list Base.option

val (<|>) : 'a option -> (unit -> 'b option) -> 'b option

val tabsize : int

val newline_indent : Base__Int.t -> Base.string

module MyInt64 : sig ... end

include sig ... end

val tempfile_path : suffix:Base.string -> Base.string

Generates a temporary file path that ends with `suffix`

module List : sig ... end