(* Utility types and functions *)

(* Identity *)

val id : 'a -> 'a

(* Combinators *)

val ( <@ )  : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val swap    : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val lambda  : 'a -> 'b -> 'a
val curry   : ('a * 'b -> 'c) -> 'a -> 'b -> 'c
val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c

(* Parametric rules for sequences

   nseq:    non-empty sequence;
   sepseq:  (possibly empty) sequence of separated items;
   nsepseq: non-empty sequence of separated items.
*)

type           'a nseq = 'a * 'a list
type ('a,'sep) nsepseq = 'a * ('sep * 'a) list
type ('a,'sep)  sepseq = ('a,'sep) nsepseq option

(* Consing *)

val nseq_cons:    'a -> 'a nseq -> 'a nseq
val nsepseq_cons: 'a -> 'sep -> ('a,'sep) nsepseq -> ('a,'sep) nsepseq
val sepseq_cons:  'a -> 'sep -> ('a,'sep)  sepseq -> ('a,'sep) nsepseq

(* Reversing *)

val nseq_rev:    'a nseq -> 'a nseq
val nsepseq_rev: ('a,'sep) nsepseq -> ('a,'sep) nsepseq
val sepseq_rev:  ('a,'sep)  sepseq -> ('a,'sep)  sepseq

(* Rightwards iterators *)

val nseq_foldl:    ('a -> 'b -> 'a) -> 'a ->        'b nseq -> 'a
val nsepseq_foldl: ('a -> 'b -> 'a) -> 'a -> ('b,'c) nsepseq -> 'a
val sepseq_foldl:  ('a -> 'b -> 'a) -> 'a -> ('b,'c)  sepseq -> 'a

val nseq_iter:     ('a -> unit) ->        'a nseq -> unit
val nsepseq_iter:  ('a -> unit) -> ('a,'b) nsepseq -> unit
val sepseq_iter:   ('a -> unit) -> ('a,'b)  sepseq -> unit

(* Leftwards iterators *)

val nseq_foldr:    ('a -> 'b -> 'b) ->        'a nseq -> 'b -> 'b
val nsepseq_foldr: ('a -> 'b -> 'b) -> ('a,'c) nsepseq -> 'b -> 'b
val sepseq_foldr:  ('a -> 'b -> 'b) -> ('a,'c)  sepseq -> 'b -> 'b

(* Conversions to lists *)

val nseq_to_list:           'a nseq -> 'a list
val nsepseq_to_list: ('a,'b) nsepseq -> 'a list
val sepseq_to_list:  ('a,'b)  sepseq -> 'a list

(* Effectful symbol generator *)

val gen_sym: unit -> string

(* General tracing function *)

val trace: string -> out_channel option -> unit

(* Printing a string in red to standard error *)

val highlight: string -> unit

(* Working with optional values *)

module Option:
  sig
    val apply: ('a -> 'b) -> 'a option -> 'b option
    val rev_apply: ('a -> 'a) option -> 'a -> 'a
    val to_string: string option -> string
  end

(* An extension to the standard module [String] *)

module String:
  sig
    include module type of String
    module Map: Map.S with type key = t
    module Set: Set.S with type elt = t
  end

(* Integer maps *)

module Int:
  sig
    type t = int
    module Map: Map.S with type key = t
    module Set: Set.S with type elt = t
  end