Utils (hax-engine.Hax

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

val some_if_true : bool -> unit option

val expect_singleton : 'a. 'a Base.list -> 'a Base.option

val let*? : Base.bool -> (Base.unit -> 'a Base.option) -> 'a 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:'a Base.List.t ->
  'a Base.List.t ->
  'a Base.List.t * 'a Base.List.t

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

val maybe_map : 
  f:('a -> 'b Base.option) ->
  'a Base.list ->
  'b Base.list Base.option

Map over a list with a option-returning function. Returns `Some` iff every calls to `f` returned `Some`.

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 -> ('a Base.list * 'a) Base.option

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

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

val (<|>) : 'a option -> (unit -> 'a option) -> 'a 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