using System.Runtime.CompilerServices;
using CanonSharp.Combinator.Abstractions;
using CanonSharp.Combinator.Parsers.Bases;
using CanonSharp.Combinator.Parsers.Modifiers;
using static CanonSharp.Combinator.ParserBuilder;

namespace CanonSharp.Combinator.Extensions;

public static class ParserExtensions
{
    #region BasesParser

    /// <summary>
    /// 选择组合子
    /// </summary>
    /// <param name="first"></param>
    /// <param name="second"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Alternative<TToken, T>(this Parser<TToken, T> first, Parser<TToken, T> second)
        => new AlternativeParser<TToken, T>(first, second);

    /// <summary>
    /// 选择组合子
    /// 按照失败的解析结果选择第二个解析器
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="resume"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Alternative<TToken, T>(this Parser<TToken, T> parser,
        Func<FailedResult<TToken, T>, Parser<TToken, T>> resume)
        => new ResumeParser<TToken, T>(parser, resume);

    /// <summary>
    /// 单子解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="next">按照输出指定下一个解析器的函数</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Bind<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, Parser<TToken, TResult>> next)
        => new BindParser<TToken, T, TResult>(parser, next);

    /// <summary>
    /// 映射解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="map">按照输出指定结果的函数</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Map<TToken, T, TResult>(this Parser<TToken, T> parser, Func<T, TResult> map)
        => new MapParser<TToken, T, TResult>(parser, map);

    /// <summary>
    /// 映射解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="result">最后的输出结果</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Map<TToken, T, TResult>(this Parser<TToken, T> parser, TResult result)
        => parser.Map(_ => result);

    /// <summary>
    /// 下一个解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="next">输入成功结果输出下一个解析器的函数</param>
    /// <param name="failedNext">输入失败结果输出下一个解析器的函数</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Next<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, Parser<TToken, TResult>> next,
        Func<FailedResult<TToken, T>, Parser<TToken, TResult>> failedNext)
        => new NextParser<TToken, T, TResult>(parser, next, failedNext);

    /// <summary>
    /// 下一个解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="next">输入成功结果输出下一个解析器的函数</param>
    /// <param name="failedHandler">输出失败结果输出后续结果的函数</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Next<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, Parser<TToken, TResult>> next, Func<FailedResult<TToken, T>, TResult> failedHandler)
        => parser.Next(next, failedResult => Pure<TToken, TResult>(failedHandler(failedResult)));

    /// <summary>
    /// 下一个解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="next">输出成功结果输出下一个解析器的函数</param>
    /// <param name="failedResult">如果失败之后返回该结果</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Next<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, Parser<TToken, TResult>> next, TResult failedResult)
        => parser.Next(next, _ => Pure<TToken, TResult>(failedResult));

    /// <summary>
    /// 下一个解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="nextResult">输入成功结果返回新的结果</param>
    /// <param name="failedResume">输入失败结果返回下一个解析器的函数</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Next<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, TResult> nextResult, Func<FailedResult<TToken, T>, Parser<TToken, TResult>> failedResume)
        => parser.Next(x => Pure<TToken, TResult>(nextResult(x)), failedResume);

    /// <summary>
    /// 下一个解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="nextResult">输入成功结果返回新的结果</param>
    /// <param name="failedResult">输入失败结果返回新的结果</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Next<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, TResult> nextResult, Func<FailedResult<TToken, T>, TResult> failedResult)
        => new SuccessfulMapParser<TToken, T, TResult>(parser, nextResult, failedResult);

    /// <summary>
    /// 下一个解析器组合子
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="successfulHandler">输入成功结果返回新结果的函数</param>
    /// <param name="failedResult">返回的失败结果</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Next<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, TResult> successfulHandler, TResult failedResult)
        => parser.Next(successfulHandler, _ => failedResult);

    #endregion

    #region ModifiedParser

    /// <summary>
    /// 在解析结果上执行指定操作
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="successfulAction">成功结果上执行的操作</param>
    /// <param name="failedAction">失败结果上执行的操作</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Do<TToken, T>(this Parser<TToken, T> parser, Action<T> successfulAction,
        Action<FailedResult<TToken, T>> failedAction)
        => new DoParser<TToken, T>(parser, successfulAction, failedAction);

    /// <summary>
    /// 在解析结果上执行指定的操作
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="successfulAction">成功结果上执行的操作</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Do<TToken, T>(this Parser<TToken, T> parser, Action<T> successfulAction)
        => parser.Do(successfulAction, _ => { });

    /// <summary>
    /// 向前看解析器
    /// 执行解析器的同时不消耗输入流
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> LookAhead<TToken, T>(this Parser<TToken, T> parser)
        => new LookAheadParser<TToken, T>(parser);

    /// <summary>
    /// 翻转上游解析器的输出结果
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="result">翻转之后的输出结果</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Not<TToken, TIgnore, T>(this Parser<TToken, TIgnore> parser, T result)
        => new ReverseParser<TToken, TIgnore, T>(parser, result);

    /// <summary>
    /// 翻转上游解析器的输出结果
    /// 输出结果默认为Unit
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, Unit> Not<TToken, TIgnore>(this Parser<TToken, TIgnore> parser)
        => parser.Not(Unit.Instance);


    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Try<TToken, T>(this Parser<TToken, T> parser,
        Func<FailedResult<TToken, T>, T> resume)
        => new TryParser<TToken, T>(parser, resume);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Try<TToken, T>(this Parser<TToken, T> parser, T result)
        => parser.Try(_ => result);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, bool> Try<TToken, T>(this Parser<TToken, T> parser)
        => parser.Next(_ => true, false).Try(false);

    #endregion

    #region Combinators

    /// <summary>
    /// 连接两个解析器，返回左边解析器的结果
    /// </summary>
    /// <param name="left"></param>
    /// <param name="right"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TLeft"></typeparam>
    /// <typeparam name="TRight"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TLeft> Left<TToken, TLeft, TRight>(this Parser<TToken, TLeft> left,
        Parser<TToken, TRight> right)
        => left.Bind(right.Map);

    /// <summary>
    /// 连接两个解析器，返回右边解析器的结果
    /// </summary>
    /// <param name="left"></param>
    /// <param name="right"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TLeft"></typeparam>
    /// <typeparam name="TRight"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TRight> Right<TToken, TLeft, TRight>(this Parser<TToken, TLeft> left,
        Parser<TToken, TRight> right)
        => left.Bind(_ => right);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static Parser<TToken, IEnumerable<T>> ManyRecursively<TToken, T>(this Parser<TToken, T> parser,
        IEnumerable<T> result)
        => parser.Next(x => parser.ManyRecursively(result.Append(x)), result);

    /// <summary>
    /// 将上游解析器运行零或若干次
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> Many<TToken, T>(this Parser<TToken, T> parser)
        => parser.ManyRecursively([]);

    /// <summary>
    /// 将上游解析器运行若干次
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> Many1<TToken, T>(this Parser<TToken, T> parser)
        => parser.Bind(x => parser.ManyRecursively([x]));

    /// <summary>
    /// 跳过执行上游解析器运行零或若干次
    /// 跳过执行不是不执行
    /// 而是不返回结果
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, Unit> SkipMany<TToken, TIgnore>(this Parser<TToken, TIgnore> parser)
        => Fix<TToken, Unit>(self => parser.Next(_ => self, Unit.Instance));

    /// <summary>
    /// 跳过执行上游解析器运行若干次
    /// 跳过执行不是不执行
    /// 而是不返回结果
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, Unit> SkipMany1<TToken, TIgnore>(this Parser<TToken, TIgnore> parser)
        => parser.Right(parser.SkipMany());

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static Parser<TToken, T> ChainRecursively<TToken, T>(Func<T, Parser<TToken, T>> chain, T value)
        => chain(value).Next(x => ChainRecursively(chain, x), value);

    /// <summary>
    /// 链式解析器组合子
    /// 按照解析结果决定下一个解析器
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="chain"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Chain<TToken, T>(this Parser<TToken, T> parser, Func<T, Parser<TToken, T>> chain)
        => parser.Bind(x => ChainRecursively(chain, x));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static Parser<TToken, IEnumerable<T>> ManyTillRecursively<TToken, T, TIgnore>(this Parser<TToken, T> parser,
        Parser<TToken, TIgnore> terminator, IEnumerable<T> result)
        => terminator.Next(_ => Pure<TToken, IEnumerable<T>>(result),
            _ => parser.Bind(x => parser.ManyTillRecursively(terminator, result.Append(x))));

    /// <summary>
    /// 执行指定解析器直到终结解析器执行成功的组合子
    /// 指定解析器可以执行零次或者多次
    /// </summary>
    /// <param name="parser">指定重复执行的解析器</param>
    /// <param name="terminator">判断是否终结的解析器</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> ManyTill<TToken, T, TIgnore>(this Parser<TToken, T> parser,
        Parser<TToken, TIgnore> terminator)
        => parser.ManyTillRecursively(terminator, []);

    /// <summary>
    /// 执行指定解析器直到终结解析器执行成功的组合子
    /// 指定解析器至少执行一次
    /// </summary>
    /// <param name="parser">指定重复执行的解析器</param>
    /// <param name="terminator">判断是否终结的解析器</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> Many1Till<TToken, T, TIgnore>(this Parser<TToken, T> parser,
        Parser<TToken, TIgnore> terminator)
        => parser.Bind(x => parser.ManyTillRecursively(terminator, [x]));

    /// <summary>
    /// 跳过指定解析器直到终结解析器执行成功的组合子
    /// 指定解析器可以执行零次或者若干次
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="terminator"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> SkipTill<TToken, TIgnore, T>(this Parser<TToken, TIgnore> parser,
        Parser<TToken, T> terminator)
        => Fix<TToken, T>(self => terminator | parser.Right(self));

    /// <summary>
    /// 跳过指定解析器直到终结解析器执行成功的组合子
    /// 指定解析器至少要执行一次
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="terminator"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="TIgnore"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Skip1Till<TToken, TIgnore, T>(this Parser<TToken, TIgnore> parser,
        Parser<TToken, T> terminator)
        => parser.Right(parser.SkipTill(terminator));

    /// <summary>
    /// 解析直到指定的解析器识别成功
    /// </summary>
    /// <param name="parser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, T> Match<TToken, T>(this Parser<TToken, T> parser)
        => SkipTill(Any<TToken>(), parser);

    /// <summary>
    /// 在左右两个解析器指定的范围内进行解析
    /// 解析类似于左右括号和左右引号类似的句式
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="left"></param>
    /// <param name="right"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TLeft"></typeparam>
    /// <typeparam name="TRight"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> Quote<TToken, T, TLeft, TRight>(this Parser<TToken, T> parser,
        Parser<TToken, TLeft> left, Parser<TToken, TRight> right)
        => left.Right(parser.ManyTill(right));

    /// <summary>
    /// 在同一个解析器指定的范围内进行解析
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="quotedParser"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TQuote"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> Quote<TToken, T, TQuote>(this Parser<TToken, T> parser,
        Parser<TToken, TQuote> quotedParser)
        => parser.Quote(quotedParser, quotedParser);

    /// <summary>
    /// 解析由分隔符解析器分割的多个符号
    /// 例如a,b,c
    /// 实际的解析器可以运行零次或者多次
    /// </summary>
    /// <param name="parser">实际的解析器</param>
    /// <param name="separator">分隔符解析器</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TSeparator"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> SeparatedBy1<TToken, T, TSeparator>(this Parser<TToken, T> parser,
        Parser<TToken, TSeparator> separator)
        => parser.Bind(x => separator.Right(parser).ManyRecursively([x]));

    /// <summary>
    /// 解析由分隔符解析器分割的多个符号
    /// 例如a,b,c
    /// 实际的解析器可以运行多次
    /// </summary>
    /// <param name="parser">实际的解析器</param>
    /// <param name="separator">分隔符解析器</param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TSeparator"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> SeparatedBy<TToken, T, TSeparator>(this Parser<TToken, T> parser,
        Parser<TToken, TSeparator> separator)
        => parser.SeparatedBy1(separator).Try([]);

    /// <summary>
    /// 解析直到使用分隔符解析器结束
    /// 例如abc.
    /// 实际的解析器可以运行零次或者多次
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="separator"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TSeparator"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> EndBy<TToken, T, TSeparator>(this Parser<TToken, T> parser,
        Parser<TToken, TSeparator> separator)
        => parser.Many().Left(separator);

    /// <summary>
    /// 解析直到使用分隔符解析器结束
    /// 例如abc.
    /// 实际的解析器至少运行一次
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="separator"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TSeparator"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> EndBy1<TToken, T, TSeparator>(this Parser<TToken, T> parser,
        Parser<TToken, TSeparator> separator)
        => parser.Many1().Left(separator);

    /// <summary>
    /// Separated和End的综合体
    /// 形如a,b,c,
    /// 实际的解析器至少运行一次
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="separator"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TSeparator"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> SeparatedOrEndBy1<TToken, T, TSeparator>(this Parser<TToken, T> parser,
        Parser<TToken, TSeparator> separator)
        => parser.SeparatedBy1(separator).Left(separator.Try());

    /// <summary>
    /// Separated和End的综合体
    /// 形如a,b,c,
    /// 实际的解析器可以运行零次或者多次
    /// </summary>
    /// <param name="parser"></param>
    /// <param name="separator"></param>
    /// <typeparam name="TToken"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TSeparator"></typeparam>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, IEnumerable<T>> SeparatedOrEndBy<TToken, T, TSeparator>(this Parser<TToken, T> parser,
        Parser<TToken, TSeparator> separator)
        => parser.SeparatedOrEndBy1(separator).Try([]);

    #endregion

    #region LINQ

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> Select<TToken, T, TResult>(this Parser<TToken, T> parser,
        Func<T, TResult> selector)
        => parser.Map(selector);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Parser<TToken, TResult> SelectMany<TToken, T, TIntermediate, TResult>(this Parser<TToken, T> parser,
        Func<T, Parser<TToken, TIntermediate>> selector, Func<T, TIntermediate, TResult> projector)
        => parser.Bind(x => selector(x).Map(y => projector(x, y)));

    #endregion
}