Parse something from an input stream (it is assumed the initial position is initPos).

>>> fmap void $ parse @(Expr Span) "x + 1"
Right (Binary [] AddOp (PathExpr [] Nothing (Path False [PathSegment "x" Nothing ()] ()) ())
                       (Lit [] (Int Dec 1 Unsuffixed ()) ())
                       ())

>>> fmap void $ parse @(Expr Span) "x + "
Left (parse failure at 1:4 (Syntax error: unexpected `<EOF>' (expected an expression)))

Same as parse, but throws a ParseFail exception if it cannot parse. This function is intended for situations in which you are already stuck catching exceptions - otherwise you should prefer parse.

>>> void $ parse' @(Expr Span) "x + 1"
Binary [] AddOp (PathExpr [] Nothing (Path False [PathSegment "x" Nothing ()] ()) ())
                (Lit [] (Int Dec 1 Unsuffixed ()) ())
                ()

>>> void $ parse' @(Expr Span) "x + "
*** Exception: parse failure at 1:4 (Syntax error: unexpected `<EOF>' (expected an expression))

Given a handle to a Rust source file, read that file and parse it into a SourceFile

>>> writeFile "empty_main.rs" "fn main() { }"
>>> fmap void $ withFile "empty_main.rs" ReadMode readSourceFile
SourceFile Nothing [] [Fn [] InheritedV "main"
                          (FnDecl [] Nothing False ())
                          Normal NotConst Rust
                          (Generics [] [] (WhereClause [] ()) ())
                          (Block [] Normal ()) ()]

Given a path pointing to a Rust source file, read that file and lex it (ignoring whitespace)

>>> writeFile "empty_main.rs" "fn main() { }"
>>> withFile "empty_main.rs" ReadMode readTokens
[fn,main,(,),{,}]

Describes things that can be parsed

Parsing and lexing monad. A value of type P a represents a parser that can be run (using execParser) to possibly produce a value of type a.

Execute the given parser on the supplied input stream at the given start position, returning either the position of an error and the error message, or the value parsed.

Same as execParser, but working from a list of tokens instead of an InputStream.

Starting position in a file.

Spans represent a contiguous region of code, delimited by two Positions. The endpoints are inclusive. Analogous to the information encoded in a selection.

Lexer for one Token. The only token this cannot produce is Interpolated.

Lexer for one non-whitespace Token. The only tokens this cannot produce are Interpolated and Space (which includes comments that aren't doc comments).

Apply the given lexer repeatedly until (but not including) the Eof token. Meant for debugging purposes - in general this defeats the point of a threaded lexer.

Parse a valid LitTok into a Lit.

Read an encoded file into an InputStream

Read an InputStream from a Handle

Convert InputStream to String.

Convert a String to an InputStream.

Signal a lexical error.

Signal a syntax error.

Exceptions that occur during parsing