ostap 0.6 · OCaml Package

module HashCons : sig ... end

module Mem : sig ... end

val join : < add : 'b -> 'c.. > as 'a option -> 'd option -> 'd option

val (<@>) : 
  ('stream, 'b, < add : 'c -> 'c.. > as 'a) Types_.result ->
  ('stream, 'b, 'a) Types_.result ->
  ('stream, 'b, 'a) Types_.result

val memo_k : 
  ('a -> < equal : 'e -> bool.. > as 'd -> ('b * 'f, 'c) Types_.tag) ->
  'a0 ->
  'g ->
  ('b * 'f, 'c) Types_.tag

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

val cast : ('a, 'b) Types_.tag -> ('c, 'd) Types_.tag

val map : 
  ('a -> 'b) ->
  ('c ->
    ('d -> < equal : 'e -> bool.. > as 'e -> ('f * 'e, 'g) Types_.tag) ->
    'h) ->
  'i ->
  ('j -> 'k -> ('f * 'e, 'g) Types_.tag) ->
  'l

val (-->) : 
  ('a ->
    ('b -> < equal : 'c -> bool.. > as 'c -> ('d * 'c, 'e) Types_.tag) ->
    'f) ->
  ('b -> 'g) ->
  'a ->
  ('g -> 'c -> ('d * 'c, 'e) Types_.tag) ->
  'f

val empty : 'a -> (unit -> 'b -> 'c) -> 'd

val fail : 'a option -> 'b -> 'c -> ('d, 'a) Types_.tag

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

val sink : 
  ('a -> 'b -> ('c * 'd, 'e) Types_.tag) ->
  'f ->
  'g ->
  ('h * 'i, 'j) Types_.tag

val memoresult : 
  (('a ->
     < equal : 'b -> bool.. > as 'b ->
     ('c * 'b, < add : 'e -> 'e.. > as 'd) Types_.tag) ->
    ('f * 'g, < add : 'i -> 'i.. > as 'h) Types_.tag) ->
  ('a0, 'j, 'k, 'l) Types_.K.t ->
  ('f * 'g, 'h) Types_.tag

val memo : 
  (< equal : 'd -> bool.. > as 'c ->
    ('a -> 'e -> ('f * 'e, < add : 'g -> 'g.. > as 'g) Types_.tag) ->
    ('b * 'h, < add : 'i -> 'i.. > as 'i) Types_.tag) ->
  'j ->
  ('a, 'e, 'b0, 'i) Types_.K.t ->
  ('b * 'h, 'i) Types_.tag

val alt : 
  (< equal : 'b -> bool.. > as 'a ->
    ('c -> 'b -> ('d * 'b, < add : 'e -> 'e.. > as 'e) Types_.tag) ->
    ('f * 'g, < add : 'i -> 'i.. > as 'h) Types_.tag) ->
  ('j -> ('c -> 'b -> ('d * 'b, 'e) Types_.tag) -> ('k, 'l, 'i) Types_.result) ->
  'b ->
  ('c, 'b, 'm, 'n) Types_.K.t ->
  ('f * 'g, 'n) Types_.tag

val (<|>) : 
  (< equal : 'a -> bool.. > as 'a ->
    ('b -> 'a -> ('c * 'a, < add : 'd -> 'd.. > as 'd) Types_.tag) ->
    ('e * 'a, < add : 'f -> 'f.. > as 'f) Types_.tag) ->
  ('a -> ('b -> 'a -> ('c * 'a, 'd) Types_.tag) -> ('a, 'e, 'f) Types_.result) ->
  'a ->
  ('b, 'a, 'e, 'f) Types_.K.t ->
  ('e * 'a, 'f) Types_.tag

val seq : 
  ('a ->
    ('b -> < equal : 'c -> bool.. > as 'c -> ('d * 'c, 'e) Types_.tag) ->
    'f) ->
  ('g -> 'h -> 'i -> ('d * 'c, 'e) Types_.tag) ->
  'j ->
  'k ->
  'l

val (|>) : 
  ('a ->
    ('b -> < equal : 'c -> bool.. > as 'c -> ('d * 'c, 'e) Types_.tag) ->
    'f) ->
  ('b -> 'c -> 'g -> ('d * 'c, 'e) Types_.tag) ->
  'a ->
  'g ->
  'f

val opt : 
  (< equal : 'b -> bool.. > as 'a ->
    ('c -> 'd -> ('e * 'f, < add : 'h -> 'h.. > as 'g) Types_.tag) ->
    ('i, 'j, 'k) Types_.result) ->
  'b ->
  ('l option, 'b, 'm, 'h) Types_.K.t ->
  ('m * 'b, 'h) Types_.tag

val (<?>) : 
  (< equal : 'a -> bool.. > as 'a ->
    ('b -> 'a -> ('c * 'a, < add : 'd -> 'd.. > as 'd) Types_.tag) ->
    ('a, 'c, 'd) Types_.result) ->
  'a ->
  ('b option, 'a, 'c, 'd) Types_.K.t ->
  ('c * 'a, 'd) Types_.tag

val manyFold : 
  ('a -> 'b -> 'c) ->
  'd ->
  (< equal : 'f -> bool.. > as 'e ->
    ('g -> 'f -> ('h * 'f, < add : 'j -> 'j.. > as 'i) Types_.tag) ->
    ('k, 'l, 'j) Types_.result) ->
  'm ->
  ('n -> 'o -> ('p * 'q, 'r) Types_.tag) ->
  ('h * 'f, 'i) Types_.tag

val many : 
  ('a, < equal : 'd -> bool.. > as 'c, 'b, < add : 'f -> 'f.. > as 'e)
    Types_.parser ->
  ('a list, 'c, 'b, 'e) Types_.parser

val (<*>) : 
  ('a, < equal : 'b -> bool.. > as 'b, 'c, < add : 'd -> 'd.. > as 'd)
    Types_.parser ->
  ('a list, 'b, 'c, 'd) Types_.parser

val someFold : 
  ('a -> 'b -> 'b) ->
  'c ->
  (< equal : 'e -> bool.. > as 'd ->
    ('a -> 'd -> ('f * 'd, < add : 'g -> 'g.. > as 'g) Types_.tag) ->
    ('d, 'f, 'g) Types_.result) ->
  'h ->
  ('i -> 'j -> ('k * 'e, 'l) Types_.tag) ->
  ('d, 'f, 'g) Types_.result

val some : 
  ('a, < equal : 'd -> bool.. > as 'c, 'b, < add : 'f -> 'f.. > as 'e)
    Types_.parser ->
  ('a list, 'c, 'b, 'e) Types_.parser

val (<+>) : 
  ('a, < equal : 'b -> bool.. > as 'b, 'c, < add : 'd -> 'd.. > as 'd)
    Types_.parser ->
  ('a list, 'b, 'c, 'd) Types_.parser

val guard : 
  ('a ->
    ('b -> < equal : 'c -> bool.. > as 'c -> ('d * 'c, 'e) Types_.tag) ->
    'f) ->
  ('g -> bool) ->
  ('h -> 'i) option ->
  'j ->
  ('k -> 'l -> ('d * 'c, 'e) Types_.tag) ->
  'm

val unwrap : ('a * 'b, 'c) Types_.tag -> ('d -> 'e) -> ('f option -> 'g) -> 'h

val altl : 
  (< equal : 'a -> bool.. > as 'a ->
    ('b, 'a, 'c, < add : 'd -> 'd.. > as 'd) Types_.K.t ->
    ('a, 'c, 'd) Types_.result)
    list ->
  'a ->
  ('b, 'a, 'c, 'd) Types_.K.t ->
  ('c * 'a, 'd) Types_.tag

val comment : 
  ('a -> 'b -> ('c, < comment : 'e -> 'f.. > as 'd) Types_.tag) ->
  'g ->
  'h ->
  'i ->
  ('j, 'k) Types_.tag

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

val fixPoly : (('a -> 'b) array -> 'c -> 'd) array -> ('a -> 'b) array

package ostap