package reparse-lwt

You can search for identifiers within the package.

in-package search v0.2.0

package reparse-lwt

reparse-lwt
- Reparse_lwt
  - Stream
    
    Infix
    
    Let_syntax
    
    Let_syntax

Legend:
Library
Module
Module type
Parameter
Class
Class type

include Reparse.PARSER with type 'a promise = 'a Lwt.t

type 'a t

type 'a promise = 'a Lwt.t

type input

val parse : input -> 'a t -> ('a, string) Stdlib.result promise

val return : 'a -> 'a t

val unit : unit t

val ignore : 'a t -> unit t

val fail : string -> 'a t

val bind : ('a -> 'b t) -> 'a t -> 'b t

val both : 'a t -> 'b t -> ('a * 'b) t

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

val map : ('a -> 'b) -> 'a t -> 'b t

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

val map3 : ('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t

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

module Infix : sig ... end

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

val (>>|) : 'a t -> ('a -> 'b) -> 'b t

val (<*>) : 'a t -> ('a -> 'b) t -> 'b t

val (<$>) : 'a t -> ('a -> 'b) -> 'b t

val (<$$>) : ('a t * 'b t) -> ('a -> 'b -> 'c) -> 'c t

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

val (<$$$$>) : 
  ('a t * 'b t * 'c t * 'd t) ->
  ('a -> 'b -> 'c -> 'd -> 'e) ->
  'e t

val (<$) : 'a -> 'b t -> 'a t

val ($>) : 'a t -> 'b -> 'b t

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

val (<*) : 'a t -> 'b t -> 'a t

val (<|>) : 'a t -> 'a t -> 'a t

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

val and* : 'a t -> 'b t -> ('a * 'b) t

val let+ : 'a t -> ('a -> 'b) -> 'b t

val and+ : 'a t -> 'b t -> ('a * 'b) t

val (<?>) : 'a t -> string -> 'a t

module Let_syntax : sig ... end

val peek_char : char t

val peek_char_opt : char option t

val peek_string : int -> string t

val any_char : char t

val unsafe_any_char : char t

val char : char -> char t

val char_if : (char -> bool) -> char t

val string_cs : string -> string t

val string_ci : string -> string t

val string_of_chars : char list -> string t

val take_string : int -> string t

val take_cstruct : int -> Cstruct.t t

val any : ?failure_msg:string -> 'a t list -> 'a t

val alt : 'a t -> 'a t -> 'a t

val optional : 'a t -> 'a option t

val not_ : 'a t -> unit t

val is : 'a t -> bool t

val is_not : 'a t -> bool t

val recur : ('a t -> 'a t) -> 'a t

val all : 'a t list -> 'a list t

val all_unit : 'a t list -> unit t

val skip : ?at_least:int -> ?up_to:int -> 'a t -> int t

val take : ?at_least:int -> ?up_to:int -> ?sep_by:'b t -> 'a t -> 'a list t

val take_while_cb : 
  ?sep_by:'b t ->
  while_:bool t ->
  on_take_cb:('a -> unit t) ->
  'a t ->
  unit t

val take_while : ?sep_by:'b t -> while_:bool t -> 'a t -> 'a list t

val take_between : ?sep_by:'b t -> start:'c t -> end_:'d t -> 'a t -> 'a list t

val alpha : char t

val alpha_num : char t

val lower_alpha : char t

val upper_alpha : char t

val bit : char t

val ascii_char : char t

val cr : char t

val crlf : string t

val control : char t

val digit : char t

val digits : string t

val dquote : char t

val hex_digit : char t

val htab : char t

val lf : char t

val octet : char t

val space : char t

val vchar : char t

val whitespace : char t

val advance : int -> unit t

val eoi : unit t

val trim_input_buffer : unit t

val pos : int t

val last_trimmed_pos : int t

val input_buffer_size : int option t

val of_promise : 'a promise -> 'a t

val create_input : char Lwt_stream.t -> input