GT (GT.GT)

module Format : sig ... end

type (!'a, !'b, !'c) t = {

gcata : 'a;
plugins : 'b;
fix : 'c;

}

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

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

val lift : 'a -> 'b -> 'a

type comparison =

| LT
| EQ
| GT

val chain_compare : comparison -> (unit -> comparison) -> comparison

val compare_primitive : 'a -> 'a -> comparison

val cmp_to_int : comparison -> int

val poly_tag : 'a -> int

val vari_tag : Obj.t -> int

val compare_poly : 'a -> 'b -> comparison

val compare_vari : 'a -> 'b -> comparison

val string_of_string : string -> string

val string_of_unit : 'a -> string

val string_of_char : char -> string

val string_of_int32 : int32 -> string

val string_of_int64 : int64 -> string

val string_of_nativeint : nativeint -> string

type nonrec bool = bool

class virtual [!'inh, 'self, !'syn] bool_t : object ... end

class 'extra html_bool_t : 'a -> object ... end

class 'extra show_bool_t : 'a -> object ... end

class 'extra enum_bool_t : 'a -> object ... end

class 'extra fmt_bool_t : 'a -> object ... end

class [!'syn, 'extra] foldl_bool_t : 'a -> object ... end

class [!'syn, 'extra] foldr_bool_t : 'a -> object ... end

class 'extra eq_bool_t : 'a -> object ... end

class 'extra compare_bool_t : 'a -> object ... end

class ['extra, !'a] gmap_bool_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_bool_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_bool_t : 'b -> object ... end

val gcata_bool : < t_bool : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val bool : 
  (['inh, bool, 'syn] bool_t ->
    'inh ->
    bool ->
    'syn,
    < compare : bool -> bool -> comparison
    ; enum : bool -> int
    ; eq : bool -> bool -> bool
    ; eval : 'env -> bool -> bool
    ; fmt : Format.formatter -> bool -> unit
    ; foldl : 'a -> bool -> 'a
    ; foldr : 'a -> bool -> 'a
    ; gmap : bool -> bool
    ; html : bool -> HTML.viewer
    ; show : bool -> string
    ; stateful : 'env -> bool -> 'env * bool >,
    (('inh -> bool -> 'syn) -> < t_bool : 'inh -> bool -> 'syn >) ->
    'inh ->
    bool ->
    'syn)
    t

type nonrec int = int

class virtual [!'inh, 'self, !'syn] int_t : object ... end

class 'extra html_int_t : 'a -> object ... end

class 'extra show_int_t : 'a -> object ... end

class 'extra enum_int_t : 'a -> object ... end

class 'extra fmt_int_t : 'a -> object ... end

class [!'syn, 'extra] foldl_int_t : 'a -> object ... end

class [!'syn, 'extra] foldr_int_t : 'a -> object ... end

class 'extra eq_int_t : 'a -> object ... end

class 'extra compare_int_t : 'a -> object ... end

class ['extra, !'a] gmap_int_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_int_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_int_t : 'b -> object ... end

val gcata_int : < t_int : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val int : 
  (['inh, int, 'syn] int_t ->
    'inh ->
    int ->
    'syn,
    < compare : int -> int -> comparison
    ; enum : int -> int
    ; eq : int -> int -> bool
    ; eval : 'env -> int -> int
    ; fmt : Format.formatter -> int -> unit
    ; foldl : 'a -> int -> 'a
    ; foldr : 'a -> int -> 'a
    ; gmap : int -> int
    ; html : int -> HTML.viewer
    ; show : int -> string
    ; stateful : 'env -> int -> 'env * int >,
    (('inh -> int -> 'syn) -> < t_int : 'inh -> int -> 'syn >) ->
    'inh ->
    int ->
    'syn)
    t

type nonrec string = string

class virtual [!'inh, 'self, !'syn] string_t : object ... end

class 'extra html_string_t : 'a -> object ... end

class 'extra show_string_t : 'a -> object ... end

class 'extra enum_string_t : 'a -> object ... end

class 'extra fmt_string_t : 'a -> object ... end

class [!'syn, 'extra] foldl_string_t : 'a -> object ... end

class [!'syn, 'extra] foldr_string_t : 'a -> object ... end

class 'extra eq_string_t : 'a -> object ... end

class 'extra compare_string_t : 'a -> object ... end

class ['extra, !'a] gmap_string_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_string_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_string_t : 'b -> object ... end

val gcata_string : < t_string : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val string : 
  (['inh, string, 'syn] string_t ->
    'inh ->
    string ->
    'syn,
    < compare : string -> string -> comparison
    ; enum : string -> int
    ; eq : string -> string -> bool
    ; eval : 'env -> string -> string
    ; fmt : Format.formatter -> string -> unit
    ; foldl : 'a -> string -> 'a
    ; foldr : 'a -> string -> 'a
    ; gmap : string -> string
    ; html : string -> HTML.viewer
    ; show : string -> string
    ; stateful : 'env -> string -> 'env * string >,
    (('inh -> string -> 'syn) -> < t_string : 'inh -> string -> 'syn >) ->
    'inh ->
    string ->
    'syn)
    t

type nonrec float = float

class virtual [!'inh, 'self, !'syn] float_t : object ... end

class 'extra html_float_t : 'a -> object ... end

class 'extra show_float_t : 'a -> object ... end

class 'extra enum_float_t : 'a -> object ... end

class 'extra fmt_float_t : 'a -> object ... end

class [!'syn, 'extra] foldl_float_t : 'a -> object ... end

class [!'syn, 'extra] foldr_float_t : 'a -> object ... end

class 'extra eq_float_t : 'a -> object ... end

class 'extra compare_float_t : 'a -> object ... end

class ['extra, !'a] gmap_float_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_float_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_float_t : 'b -> object ... end

val gcata_float : < t_float : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val float : 
  (['inh, float, 'syn] float_t ->
    'inh ->
    float ->
    'syn,
    < compare : float -> float -> comparison
    ; enum : float -> int
    ; eq : float -> float -> bool
    ; eval : 'env -> float -> float
    ; fmt : Format.formatter -> float -> unit
    ; foldl : 'a -> float -> 'a
    ; foldr : 'a -> float -> 'a
    ; gmap : float -> float
    ; html : float -> HTML.viewer
    ; show : float -> string
    ; stateful : 'env -> float -> 'env * float >,
    (('inh -> float -> 'syn) -> < t_float : 'inh -> float -> 'syn >) ->
    'inh ->
    float ->
    'syn)
    t

type nonrec char = char

class virtual [!'inh, 'self, !'syn] char_t : object ... end

class 'extra html_char_t : 'a -> object ... end

class 'extra show_char_t : 'a -> object ... end

class 'extra enum_char_t : 'a -> object ... end

class 'extra fmt_char_t : 'a -> object ... end

class [!'syn, 'extra] foldl_char_t : 'a -> object ... end

class [!'syn, 'extra] foldr_char_t : 'a -> object ... end

class 'extra eq_char_t : 'a -> object ... end

class 'extra compare_char_t : 'a -> object ... end

class ['extra, !'a] gmap_char_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_char_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_char_t : 'b -> object ... end

val gcata_char : < t_char : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val char : 
  (['inh, char, 'syn] char_t ->
    'inh ->
    char ->
    'syn,
    < compare : char -> char -> comparison
    ; enum : char -> int
    ; eq : char -> char -> bool
    ; eval : 'env -> char -> char
    ; fmt : Format.formatter -> char -> unit
    ; foldl : 'a -> char -> 'a
    ; foldr : 'a -> char -> 'a
    ; gmap : char -> char
    ; html : char -> HTML.viewer
    ; show : char -> string
    ; stateful : 'env -> char -> 'env * char >,
    (('inh -> char -> 'syn) -> < t_char : 'inh -> char -> 'syn >) ->
    'inh ->
    char ->
    'syn)
    t

type nonrec unit = unit

class virtual [!'inh, 'self, !'syn] unit_t : object ... end

class 'extra html_unit_t : 'a -> object ... end

class 'extra show_unit_t : 'a -> object ... end

class 'extra enum_unit_t : 'a -> object ... end

class 'extra fmt_unit_t : 'a -> object ... end

class [!'syn, 'extra] foldl_unit_t : 'a -> object ... end

class [!'syn, 'extra] foldr_unit_t : 'a -> object ... end

class 'extra eq_unit_t : 'a -> object ... end

class 'extra compare_unit_t : 'a -> object ... end

class ['extra, !'a] gmap_unit_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_unit_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_unit_t : 'b -> object ... end

val gcata_unit : < t_unit : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val unit : 
  (['inh, unit, 'syn] unit_t ->
    'inh ->
    unit ->
    'syn,
    < compare : unit -> unit -> comparison
    ; enum : unit -> int
    ; eq : unit -> unit -> bool
    ; eval : 'env -> unit -> unit
    ; fmt : Format.formatter -> unit -> unit
    ; foldl : 'a -> unit -> 'a
    ; foldr : 'a -> unit -> 'a
    ; gmap : unit -> unit
    ; html : unit -> HTML.viewer
    ; show : unit -> string
    ; stateful : 'env -> unit -> 'env * unit >,
    (('inh -> unit -> 'syn) -> < t_unit : 'inh -> unit -> 'syn >) ->
    'inh ->
    unit ->
    'syn)
    t

type nonrec int32 = int32

class virtual [!'inh, 'self, !'syn] int32_t : object ... end

class 'extra html_int32_t : 'a -> object ... end

class 'extra show_int32_t : 'a -> object ... end

class 'extra enum_int32_t : 'a -> object ... end

class 'extra fmt_int32_t : 'a -> object ... end

class [!'syn, 'extra] foldl_int32_t : 'a -> object ... end

class [!'syn, 'extra] foldr_int32_t : 'a -> object ... end

class 'extra eq_int32_t : 'a -> object ... end

class 'extra compare_int32_t : 'a -> object ... end

class ['extra, !'a] gmap_int32_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_int32_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_int32_t : 'b -> object ... end

val gcata_int32 : < t_int32 : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val int32 : 
  (['inh, int32, 'syn] int32_t ->
    'inh ->
    int32 ->
    'syn,
    < compare : int32 -> int32 -> comparison
    ; enum : int32 -> int
    ; eq : int32 -> int32 -> bool
    ; eval : 'env -> int32 -> int32
    ; fmt : Format.formatter -> int32 -> unit
    ; foldl : 'a -> int32 -> 'a
    ; foldr : 'a -> int32 -> 'a
    ; gmap : int32 -> int32
    ; html : int32 -> HTML.viewer
    ; show : int32 -> string
    ; stateful : 'env -> int32 -> 'env * int32 >,
    (('inh -> int32 -> 'syn) -> < t_int32 : 'inh -> int32 -> 'syn >) ->
    'inh ->
    int32 ->
    'syn)
    t

type nonrec int64 = int64

class virtual [!'inh, 'self, !'syn] int64_t : object ... end

class 'extra html_int64_t : 'a -> object ... end

class 'extra show_int64_t : 'a -> object ... end

class 'extra enum_int64_t : 'a -> object ... end

class 'extra fmt_int64_t : 'a -> object ... end

class [!'syn, 'extra] foldl_int64_t : 'a -> object ... end

class [!'syn, 'extra] foldr_int64_t : 'a -> object ... end

class 'extra eq_int64_t : 'a -> object ... end

class 'extra compare_int64_t : 'a -> object ... end

class ['extra, !'a] gmap_int64_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_int64_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_int64_t : 'b -> object ... end

val gcata_int64 : < t_int64 : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val int64 : 
  (['inh, int64, 'syn] int64_t ->
    'inh ->
    int64 ->
    'syn,
    < compare : int64 -> int64 -> comparison
    ; enum : int64 -> int
    ; eq : int64 -> int64 -> bool
    ; eval : 'env -> int64 -> int64
    ; fmt : Format.formatter -> int64 -> unit
    ; foldl : 'a -> int64 -> 'a
    ; foldr : 'a -> int64 -> 'a
    ; gmap : int64 -> int64
    ; html : int64 -> HTML.viewer
    ; show : int64 -> string
    ; stateful : 'env -> int64 -> 'env * int64 >,
    (('inh -> int64 -> 'syn) -> < t_int64 : 'inh -> int64 -> 'syn >) ->
    'inh ->
    int64 ->
    'syn)
    t

type nonrec nativeint = nativeint

class virtual [!'inh, 'self, !'syn] nativeint_t : object ... end

class 'extra html_nativeint_t : 'a -> object ... end

class 'extra show_nativeint_t : 'a -> object ... end

class 'extra enum_nativeint_t : 'a -> object ... end

class 'extra fmt_nativeint_t : 'a -> object ... end

class [!'syn, 'extra] foldl_nativeint_t : 'a -> object ... end

class [!'syn, 'extra] foldr_nativeint_t : 'a -> object ... end

class 'extra eq_nativeint_t : 'a -> object ... end

class 'extra compare_nativeint_t : 'a -> object ... end

class ['extra, !'a] gmap_nativeint_t : 'b -> object ... end

class ['extra, !'a, !'env] eval_nativeint_t : 'b -> object ... end

class ['extra, !'a, !'env] stateful_nativeint_t : 'b -> object ... end

val gcata_nativeint : < t_nativeint : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

val nativeint : 
  (['inh, nativeint, 'syn] nativeint_t ->
    'inh ->
    nativeint ->
    'syn,
    < compare : nativeint -> nativeint -> comparison
    ; enum : nativeint -> int
    ; eq : nativeint -> nativeint -> bool
    ; eval : 'env -> nativeint -> nativeint
    ; fmt : Format.formatter -> nativeint -> unit
    ; foldl : 'a -> nativeint -> 'a
    ; foldr : 'a -> nativeint -> 'a
    ; gmap : nativeint -> nativeint
    ; html : nativeint -> HTML.viewer
    ; show : nativeint -> string
    ; stateful : 'env -> nativeint -> 'env * nativeint >,
    (('inh -> nativeint -> 'syn) ->
      < t_nativeint : 'inh -> nativeint -> 'syn >) ->
    'inh ->
    nativeint ->
    'syn)
    t

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

type !'a plist = 'a list

type !'a list = 'a plist

class virtual ['ia, !'a, 'sa, !'inh, !'self, !'syn] list_t : object ... end

val gcata_list : 
  < c_Cons : 'a -> 'b list -> 'b -> 'b list -> 'c
    ; c_Nil : 'a -> 'b list -> 'c.. > ->
  'a ->
  'b list ->
  'c

class [!'a, !'self] html_list_t : (unit -> 'a -> HTML.viewer) -> 'b -> object ... end

class [!'a, !'self] show_list_t : (unit -> 'a -> string) -> (unit -> 'a list -> string) -> object ... end

class [!'a, !'self] enum_list_t : 'b -> 'c -> object ... end

class [!'a, !'b] fmt_list_t : (Format.formatter -> 'c -> unit) -> 'd -> object ... end

class [!'a, !'sa, !'self, !'b] gmap_list_t : (unit -> 'a -> 'sa) -> (unit -> 'a list -> 'sa list) -> object ... end

class [!'a, !'sa, !'self, 'syn, !'env] eval_list_t : ('env -> 'a -> 'sa) -> ('env -> 'a list -> 'sa list) -> object ... end

class [!'a, !'sa, !'self, 'syn, !'env] stateful_list_t : ('env ->
  'a ->
  'b * 'sa) -> ('b ->
  'a list ->
  'env * 'sa list) -> object ... end

class [!'a, !'syn, !'self] foldl_list_t : ('syn -> 'a -> 'b) -> ('b -> 'a list -> 'syn) -> object ... end

class [!'a, !'syn, !'self] foldr_list_t : ('syn -> 'a -> 'syn) -> ('syn -> 'a list -> 'syn) -> object ... end

class [!'a, !'self] eq_list_t : ('a -> 'a -> bool) -> ('a list -> 'a list -> bool) -> object ... end

class [!'a, !'self] compare_list_t : ('a ->
  'a ->
  comparison) -> ('a list ->
  'a list ->
  comparison) -> object ... end

val list : 
  (['ia, 'a, 'sa, 'inh, 'a list, 'syn] list_t ->
    'inh ->
    'a list ->
    'syn,
    < compare : ('a -> 'a -> comparison) -> 'a list -> 'a list -> comparison
    ; enum : ('a -> int) -> 'a list -> int
    ; eq : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
    ; eval : ('env -> 'a -> 'b) -> 'env -> 'a list -> 'b list
    ; fmt : 
      (Format.formatter -> 'a -> unit) ->
      Format.formatter ->
      'a list ->
      unit
    ; foldl : ('c -> 'a -> 'c) -> 'c -> 'a list -> 'c
    ; foldr : ('c -> 'a -> 'c) -> 'c -> 'a list -> 'c
    ; gmap : ('a -> 'b) -> 'a list -> 'b list
    ; html : ('a -> HTML.viewer) -> 'a list -> HTML.viewer
    ; show : ('a -> string) -> 'a list -> string
    ; stateful : ('env -> 'a -> 'env * 'b) -> 'env -> 'a list -> 'env * 'b list >,
    (('inh -> 'a list -> 'syn) -> ('ia, 'a, 'sa, 'inh, 'a list, 'syn) list_t) ->
    'inh ->
    'a list ->
    'syn)
    t

module Lazy : sig ... end

type !'a poption = 'a option

type !'a option = 'a poption

class virtual ['ia, !'a, 'sa, !'inh, 'self, !'syn] option_t : object ... end

val gcata_option : 
  < c_None : 'a -> 'b option -> 'c ; c_Some : 'a -> 'b option -> 'b -> 'c.. > ->
  'a ->
  'b option ->
  'c

class [!'a, 'self] show_option_t : (unit -> 'a -> string) -> 'b -> object ... end

class [!'a, 'self] html_option_t : (unit -> 'a -> HTML.viewer) -> 'b -> object ... end

class [!'a, 'self] fmt_option_t : (Format.formatter -> 'a -> unit) -> 'b -> object ... end

class [!'a, !'sa, 'self, !'b] gmap_option_t : (unit -> 'a -> 'sa) -> 'c -> object ... end

class [!'a, !'sa, 'self, 'syn, !'env] eval_option_t : ('env -> 'a -> 'sa) -> 'b -> object ... end

class [!'a, !'sa, 'self, !'b, !'env] stateful_option_t : ('env -> 'a -> 'env * 'sa) -> 'c -> object ... end

class [!'a, !'syn, 'self] foldl_option_t : ('syn -> 'a -> 'syn) -> 'b -> object ... end

class [!'a, !'syn, 'self] foldr_option_t : ('syn -> 'a -> 'syn) -> 'b -> object ... end

class [!'a, 'self] eq_option_t : ('a -> 'a -> bool) -> 'b -> object ... end

class [!'a, 'self] compare_option_t : ('a -> 'a -> comparison) -> 'b -> object ... end

val option : 
  (['ia, 'a, 'sa, 'inh, 'd, 'syn] option_t ->
    'inh ->
    'a option ->
    'syn,
    < compare : 
      ('a -> 'a -> comparison) ->
      'a option ->
      'a option ->
      comparison
    ; eq : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
    ; eval : ('env -> 'a -> 'b) -> 'env -> 'a option -> 'b option
    ; fmt : 
      (Format.formatter -> 'a -> unit) ->
      Format.formatter ->
      'a option ->
      unit
    ; foldl : ('c -> 'a -> 'c) -> 'c -> 'a option -> 'c
    ; foldr : ('c -> 'a -> 'c) -> 'c -> 'a option -> 'c
    ; gmap : ('a -> 'b) -> 'a option -> 'b option
    ; html : ('a -> HTML.viewer) -> 'a option -> HTML.viewer
    ; show : ('a -> string) -> 'a option -> string
    ; stateful : 
      ('env -> 'a -> 'env * 'b) ->
      'env ->
      'a option ->
      'env * 'b option >,
    (('e -> 'f option -> 'g) ->
      < c_None : 'e -> 'f option -> 'g
      ; c_Some : 'e -> 'f option -> 'f -> 'g.. >) ->
    'e ->
    'f option ->
    'g)
    t

type (!'a, !'b) arrow = 'a -> 'b

val gcata_arrow : < c_Arrow : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

class virtual ['ia, !'a, 'sa, 'ib, !'b, 'sb, !'inh, 'self, !'syn] arrow_t : object ... end

class [!'a, !'b, 'self] show_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, 'self] enum_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, 'self] fmt_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, 'self] html_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'sa, !'b, !'sb, 'self] gmap_arrow_t : (unit -> 'a -> 'sa) -> 'c -> 'd -> object ... end

class [!'a, !'sa, !'b, !'sb, !'env, 'self] eval_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'sa, !'b, !'sb, 'self, 'syn, !'env] stateful_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, !'syn, 'self] foldl_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, !'syn, 'self] foldr_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, 'self] eq_arrow_t : 'c -> 'd -> 'e -> object ... end

class [!'a, !'b, 'self] compare_arrow_t : 'c -> 'd -> 'e -> object ... end

val arrow : 
  (['ia, 'a, 'sa, 'ib, 'b, 'sb, 'inh, 'e, 'syn] arrow_t ->
    'inh ->
    ('a, 'b) arrow ->
    'syn,
    < compare : 
      ('a -> 'a -> comparison) ->
      ('b -> 'b -> comparison) ->
      ('a, 'b) arrow ->
      ('a, 'b) arrow ->
      comparison
    ; enum : ('a -> int) -> ('b -> int) -> ('a, 'b) arrow -> int
    ; eq : 
      ('a -> 'a -> bool) ->
      ('b -> 'b -> bool) ->
      ('a, 'b) arrow ->
      ('a, 'b) arrow ->
      bool
    ; eval : 
      ('env -> 'a -> 'c) ->
      ('env -> 'b -> 'd) ->
      'env ->
      ('a, 'b) arrow ->
      ('c, 'd) arrow
    ; fmt : 
      (Format.formatter -> 'a -> unit) ->
      (Format.formatter -> 'b -> unit) ->
      Format.formatter ->
      ('a, 'b) arrow ->
      unit
    ; foldl : 
      ('c -> 'a -> 'c) ->
      ('c -> 'b -> 'c) ->
      'c ->
      ('a, 'b) arrow ->
      'c
    ; foldr : 
      ('c -> 'a -> 'c) ->
      ('c -> 'b -> 'c) ->
      'c ->
      ('a, 'b) arrow ->
      'c
    ; gmap : ('a -> 'c) -> ('b -> 'd) -> ('a, 'b) arrow -> ('c, 'd) arrow
    ; html : 
      ('a -> HTML.viewer) ->
      ('b -> HTML.viewer) ->
      ('a, 'b) arrow ->
      HTML.viewer
    ; show : ('a -> string) -> ('b -> string) -> ('a, 'b) arrow -> string
    ; stateful : 
      ('env -> 'a -> 'env * 'c) ->
      ('env -> 'b -> 'env * 'd) ->
      'env ->
      ('a, 'b) arrow ->
      'env * ('c, 'd) arrow >,
    (('f -> 'g -> 'h) -> < c_Arrow : 'f -> 'g -> 'h.. >) ->
    'f ->
    'g ->
    'h)
    t

type !'a ref2 = 'a ref

type !'a ref = 'a ref2

class virtual ['ia, !'a, 'sa, !'inh, 'e, !'syn] ref_t : object ... end

val gcata_ref : < c_ref : 'a -> 'b -> 'c.. > -> 'a -> 'b ref -> 'c

class [!'a, 'self] fmt_ref_t : (Format.formatter -> 'a -> unit) -> 'b -> object ... end

class [!'a, 'self] html_ref_t : (unit -> 'a -> HTML.viewer) -> 'b -> object ... end

class [!'a, 'self] show_ref_t : (unit -> 'a -> string) -> 'b -> object ... end

val ref : 
  (['ia, 'a, 'sa, 'inh, 'b, 'syn] ref_t ->
    'inh ->
    'a ref ->
    'syn,
    < fmt : 
      (Format.formatter -> 'a -> unit) ->
      Format.formatter ->
      'a ref ->
      unit
    ; html : ('a -> HTML.er) -> 'a ref -> HTML.er
    ; show : ('a -> string) -> 'a ref -> string >,
    (('c -> 'd ref -> 'e) -> < c_ref : 'c -> 'd -> 'e.. >) ->
    'c ->
    'd ref ->
    'e)
    t

type !'a parray = 'a array

type !'a array = 'a parray

class virtual ['ia, !'a, 'sa, !'inh, 'self, !'syn] array_t : object ... end

val gcata_array : < do_array : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

class [!'a, 'self] show_array_t : (unit -> 'a -> string) -> 'b -> object ... end

class [!'a, 'self] enum_array_t : 'b -> 'c -> object ... end

class [!'a, !'sa, 'self, !'b] gmap_array_t : (unit -> 'a -> 'sa) -> 'c -> object ... end

class [!'a, 'self] html_array_t : (unit -> 'a -> HTML.viewer) -> 'b -> object ... end

class [!'a, 'self] fmt_array_t : (Format.formatter -> 'a -> unit) -> 'b -> object ... end

class [!'a, !'sa, 'self, !'b, !'env] eval_array_t : ('env -> 'a -> 'sa) -> 'c -> object ... end

class [!'a, !'sa, 'self, 'syn, !'b] stateful_array_t : ('b -> 'a -> 'sa * 'b) -> 'c -> object ... end

class [!'a, !'syn, 'self] foldl_array_t : ('syn -> 'a -> 'syn) -> 'b -> object ... end

class [!'a, !'syn, 'self] foldr_array_t : ('syn -> 'a -> 'syn) -> 'b -> object ... end

class [!'a, 'self] eq_array_t : ('a -> 'a -> bool) -> 'b -> object ... end

class [!'a, 'self] compare_array_t : ('a -> 'a -> comparison) -> 'b -> object ... end

val array : 
  (< do_array : 'a -> 'b -> 'c.. > ->
    'a ->
    'b ->
    'c,
    < compare : ('d -> 'd -> comparison) -> 'd array -> 'd array -> comparison
    ; enum : 'e -> unit -> 'f array -> int
    ; eq : ('g -> 'g -> bool) -> 'g array -> 'g array -> bool
    ; eval : ('h -> 'i -> 'j) -> 'h -> 'i array -> 'j array
    ; fmt : 
      (Format.formatter -> 'k -> unit) ->
      Format.formatter ->
      'k array ->
      unit
    ; foldl : ('l -> 'm -> 'l) -> 'l -> 'm array -> 'l
    ; foldr : ('n -> 'o -> 'n) -> 'n -> 'o array -> 'n
    ; gmap : ('p -> 'q) -> 'p array -> 'q array
    ; html : ('r -> HTML.viewer) -> 'r array -> HTML.viewer
    ; show : ('s -> string) -> 's array -> string
    ; stateful : 
      ('t array -> 'u -> 't * 't array) ->
      't array ->
      'u array ->
      't array * 't array >,
    (('v -> 'w -> 'x) -> < do_array : 'v -> 'w -> 'x.. >) ->
    'v ->
    'w ->
    'x)
    t

type bytes = Bytes.t

class virtual [!'inh, 'self, !'syn] bytes_t : object ... end

val gcata_bytes : < do_bytes : 'a -> 'b -> 'c.. > -> 'a -> 'b -> 'c

class 'self html_bytes_t : 'a -> object ... end

class 'self show_bytes_t : 'a -> object ... end

class ['self, !'a] gmap_bytes_t : 'b -> object ... end

class 'self fmt_bytes_t : 'a -> object ... end

class ['self, !'a, !'env] eval_bytes_t : 'b -> object ... end

class ['self, !'a, !'env] stateful_bytes_t : 'b -> object ... end

class [!'syn, 'self] foldl_bytes_t : 'a -> object ... end

class [!'syn, 'self] foldr_bytes_t : 'a -> object ... end

class 'self eq_bytes_t : 'a -> object ... end

class 'self compare_bytes_t : 'a -> object ... end

val bytes : 
  (< do_bytes : 'a -> 'b -> 'c.. > ->
    'a ->
    'b ->
    'c,
    < compare : bytes -> bytes -> comparison
    ; eq : bytes -> bytes -> bool
    ; eval : 'd -> bytes -> bytes
    ; fmt : Format.formatter -> bytes -> unit
    ; foldl : 'e -> bytes -> 'e
    ; foldr : 'f -> bytes -> 'f
    ; gmap : bytes -> bytes
    ; html : bytes -> HTML.viewer
    ; show : bytes -> string
    ; stateful : 'g -> bytes -> 'g * bytes >,
    (('h -> 'i -> 'j) -> < do_bytes : 'h -> 'i -> 'j.. >) ->
    'h ->
    'i ->
    'j)
    t

val show : ('a, < show : 'b.. >, 'c) t -> 'b

val html : ('a, < html : 'b.. >, 'c) t -> 'b

val gmap : ('a, < gmap : 'b.. >, 'c) t -> 'b

val fmt : ('a, < fmt : 'b.. >, 'c) t -> 'b

val foldl : ('a, < foldl : 'b.. >, 'c) t -> 'b

val foldr : ('a, < foldr : 'b.. >, 'c) t -> 'b

val eq : ('a, < eq : 'b.. >, 'c) t -> 'b

val compare : ('a, < compare : 'b.. >, 'c) t -> 'b

val stateful : ('a, < stateful : 'b.. >, 'c) t -> 'b

val eval : ('a, < eval : 'b.. >, 'c) t -> 'b

val enum : ('a, < enum : 'b.. >, 'c) t -> 'b