LanguageExt.Parsec by Paul Louth

<PackageReference Include="LanguageExt.Parsec" Version="3.5.36-beta" />

---

API Diff between 3.5.36-beta and 1.8.12-beta

243 Additions 54 Removals

• public static class ___ParserExt
• public static class ParserExtensions
  • public static Parser<B> Bind<A, B>(this Parser<A> self, Func<A, Parser<B>> f)
  • public static Parser<T> Filter<T>(this Parser<T> self, Func<T, bool> pred)
  • public static Parser<A> Flatten<A>(this Parser<Parser<A>> mma)
  • public static Parser<T> Flatten<T>(this Parser<Option<T>> p, Func<string> failureText)
  • public static Parser<R> Flatten<L, R>(this Parser<Either<L, R>> p, Func<L, string> failureText)
  • public static Parser<R> Flatten<R>(this Parser<Either<string, R>> p)
  • public static Parser<T> label<T>(this Parser<T> p, string expected)
  • public static Parser<U> Map<T, U>(this Parser<T> self, Func<T, U> map)
  • public static ParserResult<T> Parse<T>(this Parser<T> self, PString input)
  • public static ParserResult<T> Parse<T>(this Parser<T> self, string input)
  • public static Parser<U> Select<T, U>(this Parser<T> self, Func<T, U> map)
  • public static Parser<B> SelectMany<A, B>(this Parser<A> self, Func<A, Parser<B>> f)
  • public static Parser<V> SelectMany<T, U, V>(this Parser<T> self, Func<T, Parser<U>> bind, Func<T, U, V> project)
  • public static Parser<T> Where<T>(this Parser<T> self, Func<T, bool> pred)
• public static class ParserIOExtensions
  • public static Parser<I, B> Bind<I, A, B>(this Parser<I, A> self, Func<A, Parser<I, B>> f)
  • public static Parser<I, O> Filter<I, O>(this Parser<I, O> self, Func<O, bool> pred)
  • public static Parser<I, A> Flatten<I, A>(this Parser<I, Parser<I, A>> mma)
  • public static Parser<I, O> label<I, O>(this Parser<I, O> p, string expected)
  • public static Parser<I, U> Map<I, O, U>(this Parser<I, O> self, Func<O, U> map)
  • public static ParserResult<I, O> Parse<I, O>(this Parser<I, O> self, PString<I> input)
  • public static ParserResult<I, O> Parse<I, O>(this Parser<I, O> self, Seq<I> input, Func<I, Pos> tokenPos)
  • public static ParserResult<I, O> Parse<I, O>(this Parser<I, O> self, IEnumerable<I> input, Func<I, Pos> tokenPos)
  • public static Parser<I, U> Select<I, O, U>(this Parser<I, O> self, Func<O, U> map)
  • public static Parser<I, B> SelectMany<I, A, B>(this Parser<I, A> self, Func<A, Parser<I, B>> f)
  • public static Parser<I, V> SelectMany<I, O, U, V>(this Parser<I, O> self, Func<O, Parser<I, U>> bind, Func<O, U, V> project)
  • public static Parser<I, O> Where<I, O>(this Parser<I, O> self, Func<O, bool> pred)

LanguageExt.Parsec

• public static class ___StringExt
• public static class Char
  • public static readonly Parser<char> carriageReturn
  • public static readonly Parser<char> crlf
  • public static readonly Parser<char> CR
  • public static readonly Parser<char> CRLF
  • public static readonly Parser<char> LF
  • public static Parser<char> ch(char c)
  • public static Parser<string> str(string s)
• public static class Common
  • public static readonly Parser<Pos> getDefPos
  • public static ParserError mergeError(ParserError err1, ParserError err2)
  • public static Reply<T> mergeErrorReply<T>(ParserError err, Reply<T> reply)
  • public static bool onside(Pos pos, Pos delta)
  • public static Parser<T> setDefPos<T>(Pos defpos, Parser<T> p)
• public static class ExprIO
  • public static Parser<I, O> buildExpressionParser<I, O>(Operator<I, O>[][] operators, Parser<I, O> simpleExpr)
• public class GenLanguageDef
  • public GenLanguageDef With(string CommentStart = null, string CommentEnd = null, string CommentLine = null, bool? NestedComments = default, Parser<char> IdentStart = null, Parser<char> IdentLetter = null, Parser<char> OpStart = null, Parser<char> OpLetter = null, Lst<string> ReservedNames = null, Lst<string> ReservedOpNames = null, bool? CaseSensitive = default)
  • public GenLanguageDef With(string CommentStart = null, string CommentEnd = null, string CommentLine = null, bool? NestedComments = default, Parser<char> IdentStart = null, Parser<char> IdentLetter = null, Parser<char> OpStart = null, Parser<char> OpLetter = null, Lst<string>? ReservedNames = default, Lst<string>? ReservedOpNames = default, bool? CaseSensitive = default)
• public class GenTokenParser
  • public Parser<Lst<T>> AnglesCommaSep<T>(Parser<T> p)
  • public Parser<Lst<T>> AnglesCommaSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> AnglesSemiSep<T>(Parser<T> p)
  • public Parser<Lst<T>> AnglesSemiSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> AnglesCommaSep<T>(Parser<T> p)
  • public Parser<Seq<T>> AnglesCommaSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> AnglesSemiSep<T>(Parser<T> p)
  • public Parser<Seq<T>> AnglesSemiSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> BracesCommaSep<T>(Parser<T> p)
  • public Parser<Lst<T>> BracesCommaSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> BracesSemiSep<T>(Parser<T> p)
  • public Parser<Lst<T>> BracesSemiSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> BracesCommaSep<T>(Parser<T> p)
  • public Parser<Seq<T>> BracesCommaSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> BracesSemiSep<T>(Parser<T> p)
  • public Parser<Seq<T>> BracesSemiSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> BracketsCommaSep<T>(Parser<T> p)
  • public Parser<Lst<T>> BracketsCommaSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> BracketsSemiSep<T>(Parser<T> p)
  • public Parser<Lst<T>> BracketsSemiSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> CommaSep<T>(Parser<T> p)
  • public Parser<Lst<T>> CommaSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> BracketsCommaSep<T>(Parser<T> p)
  • public Parser<Seq<T>> BracketsCommaSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> BracketsSemiSep<T>(Parser<T> p)
  • public Parser<Seq<T>> BracketsSemiSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> CommaSep<T>(Parser<T> p)
  • public Parser<Seq<T>> CommaSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> ParensCommaSep<T>(Parser<T> p)
  • public Parser<Lst<T>> ParensCommaSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> ParensSemiSep<T>(Parser<T> p)
  • public Parser<Lst<T>> ParensSemiSep1<T>(Parser<T> p)
  • public Parser<Lst<T>> SemiSep<T>(Parser<T> p)
  • public Parser<Lst<T>> SemiSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> ParensCommaSep<T>(Parser<T> p)
  • public Parser<Seq<T>> ParensCommaSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> ParensSemiSep<T>(Parser<T> p)
  • public Parser<Seq<T>> ParensSemiSep1<T>(Parser<T> p)
  • public Parser<Seq<T>> SemiSep<T>(Parser<T> p)
  • public Parser<Seq<T>> SemiSep1<T>(Parser<T> p)
• public static class Indent
  • public static Parser<T> indented<T>(Parser<T> p)
• public static class IndentIO
  • public static Parser<TOKEN, A> indented<TOKEN, A>(int offset, Parser<TOKEN, A> p)
  • public static Parser<TOKEN, A> indented<TOKEN, A>(Parser<TOKEN, A> p)
  • public static Parser<TOKEN, A> indented1<TOKEN, A>(Parser<TOKEN, A> p)
  • public static Parser<TOKEN, A> indented2<TOKEN, A>(Parser<TOKEN, A> p)
  • public static Parser<TOKEN, A> indented4<TOKEN, A>(Parser<TOKEN, A> p)
• public class InfixOp<A> : Operator<A>
  • public readonly Parser<Func<T, T, T>> Op
  • public readonly Parser<Func<A, A, A>> Op
• public class InfixOp<I, O> : Operator<I, O>
  • public readonly Assoc Assoc
  • public readonly Parser<I, Func<O, O, O>> Op
• public static class ItemIO
  • public static Parser<A, A> anyItem<A>()
  • public static Parser<A, A> item<A>(A c)
  • public static Parser<A, A> noneOf<A>(Seq<A> str)
  • public static Parser<A, A> oneOf<A>(Seq<A> str)
  • public static Parser<A, A> satisfy<A>(Func<A, bool> pred)
  • public static Parser<A, Seq<A>> str<A>(Seq<A> s)
• public static class Operator
  • public static Operator<T> Infix<T>(Assoc assoc, Parser<Func<T, T, T>> p)
  • public static Operator<T> Postfix<T>(Parser<Func<T, T>> p)
  • public static Operator<T> Prefix<T>(Parser<Func<T, T>> p)
  • public static Operator<I, O> Infix<I, O>(Assoc assoc, Parser<I, Func<O, O, O>> p)
  • public static Operator<A> Infix<A>(Assoc assoc, Parser<Func<A, A, A>> p)
  • public static Operator<I, O> Postfix<I, O>(Parser<I, Func<O, O>> p)
  • public static Operator<A> Postfix<A>(Parser<Func<A, A>> p)
  • public static Operator<I, O> Prefix<I, O>(Parser<I, Func<O, O>> p)
  • public static Operator<A> Prefix<A>(Parser<Func<A, A>> p)
• public abstract class Operator<A>
  • public abstract Tuple<Lst<Parser<Func<T, T, T>>>, Lst<Parser<Func<T, T, T>>>, Lst<Parser<Func<T, T, T>>>, Lst<Parser<Func<T, T>>>, Lst<Parser<Func<T, T>>>> SplitOp(Tuple<Lst<Parser<Func<T, T, T>>>, Lst<Parser<Func<T, T, T>>>, Lst<Parser<Func<T, T, T>>>, Lst<Parser<Func<T, T>>>, Lst<Parser<Func<T, T>>>> state)
  • public abstract ValueTuple<Seq<Parser<Func<A, A, A>>>, Seq<Parser<Func<A, A, A>>>, Seq<Parser<Func<A, A, A>>>, Seq<Parser<Func<A, A>>>, Seq<Parser<Func<A, A>>>> SplitOp(ValueTuple<Seq<Parser<Func<A, A, A>>>, Seq<Parser<Func<A, A, A>>>, Seq<Parser<Func<A, A, A>>>, Seq<Parser<Func<A, A>>>, Seq<Parser<Func<A, A>>>> state)
• public abstract class Operator<I, O>
  • public readonly OperatorTag Tag
  • public Operator(OperatorTag tag)
  • public abstract ValueTuple<Seq<Parser<I, Func<O, O, O>>>, Seq<Parser<I, Func<O, O, O>>>, Seq<Parser<I, Func<O, O, O>>>, Seq<Parser<I, Func<O, O>>>, Seq<Parser<I, Func<O, O>>>> SplitOp(ValueTuple<Seq<Parser<I, Func<O, O, O>>>, Seq<Parser<I, Func<O, O, O>>>, Seq<Parser<I, Func<O, O, O>>>, Seq<Parser<I, Func<O, O>>>, Seq<Parser<I, Func<O, O>>>> state)
• public sealed delegate Parser<I, O> : MulticastDelegate
  • public Parser(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(PString<I> input, AsyncCallback callback, object object)
  • public virtual ParserResult<I, O> EndInvoke(IAsyncResult result)
  • public virtual ParserResult<I, O> Invoke(PString<I> input)
• public class ParserError : IEquatable<ParserError>, IComparable<ParserError>
  • public string ToStringNoPosition()
• public class ParserException : Exception
  • public ParserException()
  • public ParserException(string message)
  • public ParserException(string message, Exception innerException)
• public class ParserResult<T>
  • public Either<string, T> ToEither()
  • public Either<ERROR, T> ToEither<ERROR>(Func<string, ERROR> f)
  • public Option<T> ToOption()
• public class ParserResult<I, O>
  • public readonly Reply<I, O> Reply
  • public readonly ResultTag Tag
  • public bool IsFaulted { get; }
  • public R Match<R>(Func<ParserError, R> EmptyError, Func<ParserError, R> ConsumedError, Func<ParserResult<I, O>, R> Otherwise)
  • public R Match<R>(Func<ParserError, R> EmptyError, Func<ParserResult<I, O>, R> Otherwise)
  • public R Match<R>(Func<Reply<I, O>, R> Empty, Func<ParserResult<I, O>, R> Otherwise)
  • public R Match<R>(Func<Reply<I, O>, R> Empty, Func<Reply<I, O>, R> Consumed)
  • public R Match<R>(Func<O, PString<I>, ParserError, R> ConsumedOK, Func<ParserError, R> ConsumedError, Func<O, PString<I>, ParserError, R> EmptyOK, Func<ParserError, R> EmptyError)
  • public ParserResult<I, U> Project<S, U>(S s, Func<S, O, U> project)
  • public ParserResult<I, U> Select<U>(Func<O, U> map)
  • public ParserResult<I, O> SetEndIndex(int endIndex)
  • public Either<string, O> ToEither()
  • public Either<ERROR, O> ToEither<ERROR>(Func<string, ERROR> f)
  • public Option<O> ToOption()
• public static class ParserResultIO
  • public static ParserResult<I, O> Consumed<I, O>(Reply<I, O> reply)
  • public static ParserResult<I, O> ConsumedError<I, O>(ParserError error, Func<I, Pos> tokenPos)
  • public static ParserResult<I, O> ConsumedOK<I, O>(O value, PString<I> input)
  • public static ParserResult<I, O> ConsumedOK<I, O>(O value, PString<I> input, ParserError error)
  • public static ParserResult<I, O> Empty<I, O>(Reply<I, O> reply)
  • public static ParserResult<I, O> EmptyError<I, O>(ParserError error, Func<I, Pos> tokenPos)
  • public static ParserResult<I, O> EmptyOK<I, O>(O value, PString<I> input, ParserError error = null)
• public class PostfixOp<A> : Operator<A>
  • public readonly Parser<Func<T, T>> Op
  • public readonly Parser<Func<A, A>> Op
• public class PostfixOp<I, O> : Operator<I, O>
  • public readonly Parser<I, Func<O, O>> Op
• public class PrefixOp<A> : Operator<A>
  • public readonly Parser<Func<T, T>> Op
  • public readonly Parser<Func<A, A>> Op
• public class PrefixOp<I, O> : Operator<I, O>
  • public readonly Parser<I, Func<O, O>> Op
• public static class Prim
  • public static Parser<Unit> unitp { get; }
  • public static Parser<Option<double>> asDouble(Parser<IEnumerable<char>> p)
  • public static Parser<Option<float>> asFloat(Parser<IEnumerable<char>> p)
  • public static Parser<Option<int>> asInteger(Parser<IEnumerable<char>> p)
  • public static Parser<Option<int>> asInteger(Parser<IEnumerable<char>> p, int fromBase)
  • public static Parser<string> asString(Parser<IEnumerable<char>> p)
  • public static readonly Parser<Unit> unitp
  • public static Parser<Option<double>> asDouble(Parser<Seq<char>> p)
  • public static Parser<Option<float>> asFloat(Parser<Seq<char>> p)
  • public static Parser<Option<int>> asInteger(Parser<Seq<char>> p)
  • public static Parser<Option<int>> asInteger(Parser<Seq<char>> p, int fromBase)
  • public static Parser<string> asString(Parser<Seq<char>> p)
  • public static Parser<IEnumerable<T>> chain<T>(Parser<T>[] ps)
  • public static Parser<IEnumerable<T>> chain<T>(IEnumerable<Parser<T>> ps)
  • public static Parser<Seq<T>> chain<T>(Parser<T>[] ps)
  • public static Parser<Seq<T>> chain<T>(Seq<Parser<T>> ps)
  • public static Parser<T> choice<T>(IEnumerable<Parser<T>> ps)
  • public static Parser<IEnumerable<T>> count<S, T>(int n, Parser<T> p)
  • public static Parser<T> choice<T>(Seq<Parser<T>> ps)
  • public static Parser<Seq<T>> cons<T>(Parser<T> p, Parser<Seq<T>> ps)
  • public static Parser<Seq<T>> count<T>(int n, Parser<T> p)
  • public static Parser<IEnumerable<T>> endBy<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<IEnumerable<T>> endBy1<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> endBy<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> endBy1<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> flatten<T>(Parser<Seq<Seq<T>>> ssp)
  • public static Parser<IEnumerable<T>> many<T>(Parser<T> p)
  • public static Parser<IEnumerable<T>> many1<T>(Parser<T> p)
  • public static Parser<IEnumerable<T>> manyUntil<T, U>(Parser<T> p, Parser<U> end)
  • public static ParserError mergeError(ParserError err1, ParserError err2)
  • public static Reply<T> mergeErrorReply<T>(ParserError err, Reply<T> reply)
  • public static Parser<Seq<T>> many<T>(Parser<T> p)
  • public static Parser<Seq<T>> many1<T>(Parser<T> p)
  • public static Parser<Seq<T>> manyn<T>(Parser<T> p, int n)
  • public static Parser<Seq<T>> manyn0<T>(Parser<T> p, int n)
  • public static Parser<Seq<T>> manyn1<T>(Parser<T> p, int n)
  • public static Parser<Seq<T>> manyUntil<T, U>(Parser<T> p, Parser<U> end)
  • public static Parser<IEnumerable<T>> optionalSeq<T>(Parser<T> p)
  • public static Parser<Seq<T>> optionalSeq<T>(Parser<T> p)
  • public static Parser<IEnumerable<T>> sepBy<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<IEnumerable<T>> sepBy1<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<IEnumerable<T>> sepEndBy<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<IEnumerable<T>> sepEndBy1<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> sepBy<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> sepBy1<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> sepEndBy<S, T>(Parser<T> p, Parser<S> sep)
  • public static Parser<Seq<T>> sepEndBy1<S, T>(Parser<T> p, Parser<S> sep)
• public static class PrimIO
  • public static Parser<I, Option<double>> asDouble<I>(Parser<I, Seq<char>> p)
  • public static Parser<I, Option<double>> asDouble<I>(Parser<I, string> p)
  • public static Parser<I, Option<float>> asFloat<I>(Parser<I, Seq<char>> p)
  • public static Parser<I, Option<float>> asFloat<I>(Parser<I, string> p)
  • public static Parser<I, Option<int>> asInteger<I>(Parser<I, Seq<char>> p)
  • public static Parser<I, Option<int>> asInteger<I>(Parser<I, string> p)
  • public static Parser<I, Option<int>> asInteger<I>(Parser<I, Seq<char>> p, int fromBase)
  • public static Parser<I, Option<int>> asInteger<I>(Parser<I, string> p, int fromBase)
  • public static Parser<I, string> asString<I>(Parser<I, Seq<char>> p)
  • public static Parser<I, string> asString<I, O>(Parser<I, Seq<O>> p)
  • public static Parser<I, string> asString<I, O>(Parser<I, O> p)
  • public static Parser<I, O> attempt<I, O>(Parser<I, O> p)
  • public static Parser<I, O> between<L, R, I, O>(Parser<I, L> open, Parser<I, R> close, Parser<I, O> inner)
  • public static Parser<I, Seq<O>> chain<I, O>(Parser<I, O>[] ps)
  • public static Parser<I, Seq<O>> chain<I, O>(Seq<Parser<I, O>> ps)
  • public static Parser<I, O> chainl<I, O>(Parser<I, O> p, Parser<I, Func<O, O, O>> op, O x)
  • public static Parser<I, O> chainl1<I, O>(Parser<I, O> p, Parser<I, Func<O, O, O>> op)
  • public static Parser<I, O> chainr<I, O>(Parser<I, O> p, Parser<I, Func<O, O, O>> op, O x)
  • public static Parser<I, O> chainr1<I, O>(Parser<I, O> p, Parser<I, Func<O, O, O>> op)
  • public static Parser<TOKEN, A> children<TOKEN, A>(Parser<TOKEN, Seq<TOKEN>> children, Parser<TOKEN, A> p)
  • public static Parser<I, O> choice<I, O>(Parser<I, O>[] ps)
  • public static Parser<I, O> choice<I, O>(Seq<Parser<I, O>> ps)
  • public static Parser<I, Seq<O>> count<S, I, O>(int n, Parser<I, O> p)
  • public static Parser<I, O> either<I, O>(Parser<I, O> p, Parser<I, O> q)
  • public static Parser<I, Seq<O>> endBy<S, I, O>(Parser<I, O> p, Parser<I, S> sep)
  • public static Parser<I, Seq<O>> endBy1<S, I, O>(Parser<I, O> p, Parser<I, S> sep)
  • public static Parser<I, Unit> eof<I>()
  • public static Parser<I, O> failure<I, O>(string msg)
  • public static Parser<I, int> getIndex<I>()
  • public static Parser<I, Pos> getPos<I>()
  • public static Parser<I, S> getState<I, S>()
  • public static Parser<I, O> lazyp<I, O>(Func<Parser<I, O>> fn)
  • public static Parser<I, O> lookAhead<I, O>(Parser<I, O> p)
  • public static Parser<I, Seq<O>> many<I, O>(Parser<I, O> p)
  • public static Parser<I, Seq<O>> many1<I, O>(Parser<I, O> p)
  • public static Parser<I, Seq<O>> manyUntil<I, O, U>(Parser<I, O> p, Parser<I, U> end)
  • public static Parser<I, Unit> notFollowedBy<I, O>(Parser<I, O> p)
  • public static Parser<I, Option<O>> optional<I, O>(Parser<I, O> p)
  • public static Parser<I, O[]> optionalArray<I, O>(Parser<I, O> p)
  • public static Parser<I, Lst<O>> optionalList<I, O>(Parser<I, O> p)
  • public static Parser<I, Seq<O>> optionalSeq<I, O>(Parser<I, O> p)
  • public static Parser<I, O> optionOrElse<I, O>(O x, Parser<I, O> p)
  • public static ParserResult<I, O> parse<I, O>(Parser<I, O> p, PString<I> input)
  • public static ParserResult<I, O> parse<I, O>(Parser<I, O> p, Seq<I> input, Func<I, Pos> tokenPos)
  • public static Parser<I, O> result<I, O>(O value)
  • public static Parser<I, Seq<O>> sepBy<S, I, O>(Parser<I, O> p, Parser<I, S> sep)
  • public static Parser<I, Seq<O>> sepBy1<S, I, O>(Parser<I, O> p, Parser<I, S> sep)
  • public static Parser<I, Seq<O>> sepEndBy<S, I, O>(Parser<I, O> p, Parser<I, S> sep)
  • public static Parser<I, Seq<O>> sepEndBy1<S, I, O>(Parser<I, O> p, Parser<I, S> sep)
  • public static Parser<I, Unit> setState<I, S>(S state)
  • public static Parser<I, Unit> skipMany<I, O>(Parser<I, O> p)
  • public static Parser<I, Unit> skipMany1<I, O>(Parser<I, O> p)
  • public static Parser<I, O> unexpected<I, O>(string msg)
  • public static Parser<I, Unit> unitp<I>()
  • public static Parser<I, O> zero<I, O>()
• public class PString
  • public readonly string Value
• public class PString<T>
  • public readonly int EndIndex
  • public readonly int Index
  • public readonly Func<T, Pos> TokenPos
  • public readonly Option<object> UserState
  • public readonly T[] Value
  • public Pos Pos { get; }
  • public PString(T[] value, int index, int endIndex, Option<object> userState, Func<T, Pos> tokenPos)
  • public static PString<T> Zero(Func<T, Pos> tokenPos)
  • public PString<U> Cast<U>() where U : T
  • public PString<T> SetEndIndex(int endIndex)
  • public PString<T> SetIndex(int index)
  • public PString<T> SetUserState(object state)
  • public PString<T> SetValue(T[] value)
• public static class Reply
  • public static Reply<I, O> Error<I, O>(ParserErrorTag tag, Pos pos, string message, Lst<string> expected, Func<I, Pos> tokenPos)
  • public static Reply<I, O> Error<I, O>(ParserError error, Func<I, Pos> tokenPos)
  • public static Reply<I, O> OK<I, O>(O result, PString<I> remaining, ParserError error = null)
• public class Reply<I, O>
  • public readonly ParserError Error
  • public readonly O Result
  • public readonly PString<I> State
  • public readonly ReplyTag Tag
  • public Reply<I, U> Project<S, U>(S s, Func<S, O, U> project)
  • public Reply<I, U> Select<U>(Func<O, U> map)
• public static class StringAndCollectionExtensions
  • public static PString ToPString(this string value)
  • public static PString<T> ToPString<T>(this IEnumerable<T> value, Func<T, Pos> tokenPos)
  • public static PString<T> ToPString<T>(this Seq<T> value, Func<T, Pos> tokenPos)