Parsec

public let Lazy :

public let LazyStream :

public func implode(cs : List.List<Char>) : Text

public func explode(t : Text) : List.List<Char>

public func parse<Token, A>(pa : Parser<Token, A>, input : LazyStream.t<Token>) : ?A

type Input<Token> = LazyStream.t<Token>

type Monad<Token, Result> = ?(Result, Input<Token>)

type Parser<Token, Result> = Input<Token> -> Monad<Token, Result>

public func ret<Token, A>(x : A) : Parser<Token, A>

public func bind<Token, A, B>(pa : Parser<Token, A>, f : A -> Parser<Token, B>) : Parser<Token, B>

public func pair<Token, A, B>(pa : Parser<Token, A>, pb : Parser<Token, B>) : Parser<Token, (A, B)>

public func choose<Token, A>(pa1 : Parser<Token, A>, pa2 : Parser<Token, A>) : Parser<Token, A>

public func mzero<Token, A>() : Parser<Token, A>

public func any<Token>(ls : Input<Token>) : Monad<Token, Token>

public func token<Token, A>(f : Token -> ?A) : Parser<Token, A>

public func satisfy<Token>(test : Token -> Bool) : Parser<Token, Token>

public func eof<Token, A>(a : A) : Parser<Token, A>

public func delay<Token, Result>(f : () -> Parser<Token, Result>) : Parser<Token, Result>

public func map<Token, A, B>(pa : Parser<Token, A>, f : A -> B) : Parser<Token, B>

public func left<Token, A, B>(pa : Parser<Token, A>, pb : Parser<Token, B>) : Parser<Token, A>

public func cons<Token, A>(pa : Parser<Token, A>, pas : Parser<Token, List.List<A>>) : Parser<Token, List.List<A>>

public func choice<Token, A>(ps : [Parser<Token, A>]) : Parser<Token, A>

public func count<Token, A>(n : Nat, pa : Parser<Token, A>) : Parser<Token, List.List<A>>

public func between<Token, A, B, C>(
  pa : Parser<Token, A>,
  pb : Parser<Token, B>,
  pc : Parser<Token, C>
) : Parser<Token, B>

public func option<Token, A>(default : A, pa : Parser<Token, A>) : Parser<Token, A>

public func optional<Token, A>(pa : Parser<Token, A>) : Parser<Token, ()>

public func skipMany<Token, A>(pa : Parser<Token, A>) : Parser<Token, ()>

public func skipMany1<Token, A>(pa : Parser<Token, A>) : Parser<Token, ()>

public func many<Token, A>(pa : Parser<Token, A>) : Parser<Token, List.List<A>>

public func many1<Token, A>(pa : Parser<Token, A>) : Parser<Token, List.List<A>>

public func sepBy1<Token, A, B>(pa : Parser<Token, A>, sep : Parser<Token, B>) : Parser<Token, List.List<A>>

public func sepBy<Token, A, B>(pa : Parser<Token, A>, sep : Parser<Token, B>) : Parser<Token, List.List<A>>

public func endBy1<Token, A, B>(pa : Parser<Token, A>, sep : Parser<Token, B>) : Parser<Token, List.List<A>>

public func endBy<Token, A, B>(pa : Parser<Token, A>, sep : Parser<Token, B>) : Parser<Token, List.List<A>>

public func chainl1<Token, A, B>(pa : Parser<Token, A>, op : Parser<Token, (A, A) -> A>) : Parser<Token, A>

public func chainl<Token, A, B>(
  pa : Parser<Token, A>,
  op : Parser<Token, (A, A) -> A>,
  default : A
) : Parser<Token, A>

public func chainr1<Token, A, B>(pa : Parser<Token, A>, op : Parser<Token, (A, A) -> A>) : Parser<Token, A>

public func chainr<Token, A, B>(
  pa : Parser<Token, A>,
  op : Parser<Token, (A, A) -> A>,
  default : A
) : Parser<Token, A>

public func exactly<Token>(eq : (Token, Token) -> Bool, t : Token) : Parser<Token, Token>

public func oneOf<Token>(eq : (Token, Token) -> Bool, tokens : [Token]) : Parser<Token, Token>

public func noneOf<Token>(eq : (Token, Token) -> Bool, tokens : [Token]) : Parser<Token, Token>

public func range<Token>(
  leq : (Token, Token) -> Bool,
  l : Token,
  r : Token
) : Parser<Token, Token>

class CharParsers()

public let space : Parser<Char, Char>

public let spaces : Parser<Char, ()>

public let newline : Parser<Char, Char>

public let tab : Parser<Char, Char>

public let upper : Parser<Char, Char>

public let lower : Parser<Char, Char>

public let digit : Parser<Char, Char>

public let letter : Parser<Char, Char>

public let alphaNum : Parser<Char, Char>

public let hexDigit : Parser<Char, Char>

public let octDigit : Parser<Char, Char>

public func lexeme<A>(pa : Parser<Char, A>) : Parser<Char, A>

public func token(t : Text) : Parser<Char, Text>