opal 0.1.0 · OCaml Package

module LazyStream : sig ... end

val implode : char list -> string

val explode : string -> char list

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

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

type 'token input = 'token LazyStream.t

type ('token, 'result) monad = ('result * 'token input) option

type ('token, 'result) parser = 'token input -> ('result * 'token input) option

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

val (>>=) : 
  ('a -> ('b * 'c) option) ->
  ('d -> 'e -> 'f option) ->
  'g ->
  'f option

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

val scan : ('a -> ('b * 'c) option) -> 'd -> 'e LazyStream.t

val mzero : 'a -> 'b option

val any : 'a LazyStream.t -> ('b * 'a LazyStream.t) option

val satisfy : ('a -> bool) -> 'b LazyStream.t -> ('c * 'b LazyStream.t) option

val eof : 'a -> 'b LazyStream.t -> ('c * 'd LazyStream.t) option

val (=>) : ('a -> ('b * 'c) option) -> ('d -> 'e) -> 'a -> ('f * 'g) option

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

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

val (<~>) : 
  ('a -> ('b * 'c) option) ->
  ('d -> ('e list * 'f) option) ->
  'a ->
  ('e list * 'g) option

val choice : ('a -> 'b option) list -> 'a -> 'b option

val count : int -> ('a -> ('b * 'c) option) -> 'c -> ('b list * 'd) option

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

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

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

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

val skip_many1 : ('a -> ('b * 'a) option) -> 'c -> (unit * 'a) option

val many : ('a -> ('b * 'c) option) -> 'd -> ('e list * 'f) option

val many1 : ('a -> ('b * 'a) option) -> 'c -> ('d list * 'e) option

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

val sep_by : 
  ('a -> ('b * 'c) option) ->
  ('c -> ('d * 'a) option) ->
  'e ->
  ('b list * 'c) option

val end_by1 : 
  ('a -> ('b * 'c) option) ->
  ('d -> ('e * 'f) option) ->
  'g ->
  ('b list * 'f) option

val end_by : 
  ('a -> ('b * 'c) option) ->
  ('c -> ('d * 'a) option) ->
  'e ->
  ('b list * 'a) option

val chainl1 : 
  ('a -> ('b * 'c) option) ->
  ('d -> (('e -> 'f -> 'g) * 'h) option) ->
  'a ->
  ('i * 'j) option

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

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

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

val exactly : 'a -> 'b LazyStream.t -> ('b * 'b LazyStream.t) option

val one_of : 'a list -> 'b LazyStream.t -> ('b * 'b LazyStream.t) option

val none_of : 
  'a ->
  'b list LazyStream.t ->
  ('b list * 'b list LazyStream.t) option

val range : 'a -> 'b -> 'c LazyStream.t -> ('c * 'c LazyStream.t) option

val space : char LazyStream.t -> (char * char LazyStream.t) option

val spaces : char LazyStream.t -> (unit * char LazyStream.t) option

val newline : char LazyStream.t -> (char * char LazyStream.t) option

val tab : char LazyStream.t -> (char * char LazyStream.t) option

val upper : char LazyStream.t -> (char * char LazyStream.t) option

val lower : char LazyStream.t -> (char * char LazyStream.t) option

val digit : char LazyStream.t -> (char * char LazyStream.t) option

val letter : char LazyStream.t -> (char * char LazyStream.t) option

val alpha_num : char LazyStream.t -> (char * char LazyStream.t) option

val hex_digit : char LazyStream.t -> (char * char LazyStream.t) option

val oct_digit : char LazyStream.t -> (char * char LazyStream.t) option

val lexeme : (char LazyStream.t -> 'a option) -> char LazyStream.t -> 'a option

val token : string -> char LazyStream.t -> (string * char LazyStream.t) option

package opal