feat: Parser Combinator库和词法分析器 (#2)

Reviewed-on: https://git.bupt-hpc.cn/jackfiled/CanonSharp/pulls/2
Co-authored-by: jackfiled <xcrenchangjun@outlook.com>
Co-committed-by: jackfiled <xcrenchangjun@outlook.com>

CanonSharp.Combinator/Parsers/Bases/AlternativeParser.cs

@@ -0,0 +1,21 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Bases;
+
+/// <summary>
+/// 选择解析器
+/// 如果第一个不成功则调用第二个
+/// </summary>
+/// <param name="first">第一个解析器</param>
+/// <param name="second">第二个解析器</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析器结果类型</typeparam>
+internal sealed class AlternativeParser<TToken, T>(Parser<TToken, T> first, Parser<TToken, T> second)
+    : Parser<TToken, T>
+{
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+    {
+        return first.Run(state, result => result.CaseOf(continuation, _ => second.Run(state, continuation)));
+    }
+}

CanonSharp.Combinator/Parsers/Bases/BindParser.cs

@@ -0,0 +1,20 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Bases;
+
+/// <summary>
+/// 单子解析器
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="next">下游解析器生成函数</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="TIntermediate">上游解析器结果类型</typeparam>
+/// <typeparam name="T">下游解析器结果类型</typeparam>
+internal sealed class BindParser<TToken, TIntermediate, T>(
+    Parser<TToken, TIntermediate> parser,
+    Func<TIntermediate, Parser<TToken, T>> next) : Parser<TToken, T>
+{
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+        => parser.Run(state, result => result.Next(next, continuation));
+}

CanonSharp.Combinator/Parsers/Bases/FixParser.cs

@@ -0,0 +1,33 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Bases;
+
+/// <summary>
+/// 修正？解析器
+/// 感觉是一种递归的高级实现？
+///
+/// </summary>
+/// <typeparam name="TToken"></typeparam>
+/// <typeparam name="T"></typeparam>
+internal sealed class FixParser<TToken, T> : Parser<TToken, T>
+{
+    private readonly Parser<TToken, T> _parser;
+
+    public FixParser(Func<Parser<TToken, T>, Parser<TToken, T>> func)
+    {
+        _parser = func(this);
+    }
+
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+        => _parser.Run(state, continuation);
+}
+
+internal sealed class FixParser<TToken, TParameter, T>(
+    Func<Func<TParameter, Parser<TToken, T>>, TParameter, Parser<TToken, T>> func,
+    TParameter parameter) : Parser<TToken, T>
+{
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+        => func(p => new FixParser<TToken, TParameter, T>(func, p), parameter).Run(state, continuation);
+}

CanonSharp.Combinator/Parsers/Bases/MapParser.cs

@@ -0,0 +1,21 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Bases;
+
+/// <summary>
+/// 映射解析器
+/// 提供一个函数修改上游解析器返回的结果
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="func">修改上游解析器返回结果的</param>
+/// <typeparam name="TToken"></typeparam>
+/// <typeparam name="TIntermediate"></typeparam>
+/// <typeparam name="T"></typeparam>
+internal sealed class MapParser<TToken, TIntermediate, T>(
+    Parser<TToken, TIntermediate> parser,
+    Func<TIntermediate, T> func) : Parser<TToken, T>
+{
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+        => parser.Run(state, result => continuation(result.Map(func)));
+}

CanonSharp.Combinator/Parsers/Bases/NextParser.cs

@@ -0,0 +1,26 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Bases;
+
+/// <summary>
+/// 下一步解析器
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="successfulParser">成功情况下的解析器函数</param>
+/// <param name="failedParser">失败情况下的解析器函数</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="TIntermediate">上游解析器结果类型</typeparam>
+/// <typeparam name="T">最终解析结果类型</typeparam>
+internal sealed class NextParser<TToken, TIntermediate, T>(
+    Parser<TToken, TIntermediate> parser,
+    Func<TIntermediate, Parser<TToken, T>> successfulParser,
+    Func<FailedResult<TToken, TIntermediate>, Parser<TToken, T>> failedParser) : Parser<TToken, T>
+{
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+    {
+        return parser.Run(state, result => result.CaseOf(
+            successfulResult => successfulResult.Next(successfulParser, continuation),
+            failedResult => failedParser(failedResult).Run(state, continuation)));
+    }
+}

CanonSharp.Combinator/Parsers/Bases/ResumeParser.cs

@@ -0,0 +1,24 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Bases;
+
+/// <summary>
+/// 恢复解析器
+/// 在上游解析器失败的情况下调用指定恢复函数返回的解析器
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="failedHandler">返回新解析器的恢复函数</param>
+/// <typeparam name="TToken">输入令牌类型</typeparam>
+/// <typeparam name="T">解析结果类型</typeparam>
+internal sealed class ResumeParser<TToken, T>(
+    Parser<TToken, T> parser,
+    Func<FailedResult<TToken, T>, Parser<TToken, T>> failedHandler) : Parser<TToken, T>
+{
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+    {
+        return parser.Run(state,
+            result => result.CaseOf(continuation,
+                failedResult => failedHandler(failedResult).Run(state, continuation)));
+    }
+}

CanonSharp.Combinator/Parsers/ModifiedParser.cs

@@ -0,0 +1,27 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers;
+
+/// <summary>
+/// 修改解析器返回结果的解析器基类
+/// </summary>
+/// <param name="parser">需要修改结果的解析器</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="TIntermediate">需要修改结果的解析器</typeparam>
+/// <typeparam name="T">最终返回的解析结果</typeparam>
+public abstract class ModifiedParser<TToken, TIntermediate, T>(Parser<TToken, TIntermediate> parser) : Parser<TToken, T>
+{
+    protected abstract ParseResult<TToken, T> Fail<TState>(TState state,
+        FailedResult<TToken, TIntermediate> failedResult)
+        where TState : IReadState<TToken, TState>;
+
+    protected abstract ParseResult<TToken, T> Succeed<TState>(TState state,
+        SuccessfulResult<TToken, TIntermediate> successfulResult)
+        where TState : IReadState<TToken, TState>;
+
+    internal override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+        => parser.Run(state, result => result.CaseOf(
+            success => continuation(Succeed(state, success)),
+            failure => continuation(Fail(state, failure))));
+}

CanonSharp.Combinator/Parsers/Modifiers/DoParser.cs

@@ -0,0 +1,30 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Modifiers;
+
+/// <summary>
+/// 对结果运行指定操作，但是不做修改操作的解析器
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="succeed">对成功结果的操作</param>
+/// <param name="fail">对失败结果的操作</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析结果类型</typeparam>
+internal sealed class DoParser<TToken, T>(
+    Parser<TToken, T> parser,
+    Action<T> succeed,
+    Action<FailedResult<TToken, T>> fail) : ModifiedParser<TToken, T, T>(parser)
+{
+    protected override ParseResult<TToken, T> Succeed<TState>(TState state,
+        SuccessfulResult<TToken, T> successfulResult)
+    {
+        succeed(successfulResult.Value);
+        return successfulResult;
+    }
+
+    protected override ParseResult<TToken, T> Fail<TState>(TState state, FailedResult<TToken, T> failedResult)
+    {
+        fail(failedResult);
+        return failedResult;
+    }
+}

CanonSharp.Combinator/Parsers/Modifiers/LookAheadParser.cs

@@ -0,0 +1,21 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Modifiers;
+
+/// <summary>
+/// 向前看解析器
+/// 使用传入的解析器向前解析
+/// 但是返回的结果中输入流读取状态不前移
+/// </summary>
+/// <param name="parser">需要向前看的解析器</param>
+/// <typeparam name="TToken">输入流令牌</typeparam>
+/// <typeparam name="T">返回的解析结果类型</typeparam>
+internal sealed class LookAheadParser<TToken, T>(Parser<TToken, T> parser) : ModifiedParser<TToken, T, T>(parser)
+{
+    protected override ParseResult<TToken, T> Succeed<TState>(TState state,
+        SuccessfulResult<TToken, T> successfulResult)
+        => ParseResultBuilder.Succeed<TToken, TState, T>(successfulResult.Value, state);
+
+    protected override ParseResult<TToken, T> Fail<TState>(TState state, FailedResult<TToken, T> failedResult)
+        => ParseResultBuilder.Fail<TToken, TState, T>($"Failed when looking ahead: {failedResult}", state);
+}

CanonSharp.Combinator/Parsers/Modifiers/ReverseParser.cs

@@ -0,0 +1,26 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Modifiers;
+
+/// <summary>
+/// 翻转结果的解析器
+/// 当成功时失败
+/// 当失败时返回指定的成功结果
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="result">期望中的结果</param>
+/// <typeparam name="TToken">输入流的类型</typeparam>
+/// <typeparam name="TIntermediate">上游解析器结果类型</typeparam>
+/// <typeparam name="T">最终的返回结果</typeparam>
+internal sealed class ReverseParser<TToken, TIntermediate, T>(Parser<TToken, TIntermediate> parser, T result)
+    : ModifiedParser<TToken, TIntermediate, T>(parser)
+{
+    protected override ParseResult<TToken, T> Succeed<TState>(TState state,
+        SuccessfulResult<TToken, TIntermediate> successfulResult)
+        => ParseResultBuilder.Fail<TToken, TState, T>($"Unexpected successful result: {successfulResult.Value}",
+            state);
+
+    protected override ParseResult<TToken, T> Fail<TState>(TState state,
+        FailedResult<TToken, TIntermediate> failedResult)
+        => ParseResultBuilder.Succeed<TToken, TState, T>(result, state);
+}

CanonSharp.Combinator/Parsers/Modifiers/SuccessfulMapParser.cs

@@ -0,0 +1,26 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Modifiers;
+
+/// <summary>
+/// 成功映射的解析器
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="successfulHandler">当上游成功时的处理函数</param>
+/// <param name="failedHandler">当上游失败时的处理函数</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="TIntermediate">上游解析器解析结果类型</typeparam>
+/// <typeparam name="T">最终的解析结果类型</typeparam>
+internal sealed class SuccessfulMapParser<TToken, TIntermediate, T>(
+    Parser<TToken, TIntermediate> parser,
+    Func<TIntermediate, T> successfulHandler,
+    Func<FailedResult<TToken, TIntermediate>, T> failedHandler) : ModifiedParser<TToken, TIntermediate, T>(parser)
+{
+    protected override ParseResult<TToken, T> Succeed<TState>(TState state,
+        SuccessfulResult<TToken, TIntermediate> successfulResult)
+        => successfulResult.Map(successfulHandler);
+
+    protected override ParseResult<TToken, T> Fail<TState>(TState state,
+        FailedResult<TToken, TIntermediate> failedResult)
+        => ParseResultBuilder.Succeed<TToken, TState, T>(failedHandler(failedResult), state);
+}

CanonSharp.Combinator/Parsers/Modifiers/TryParser.cs

@@ -0,0 +1,23 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Modifiers;
+
+/// <summary>
+/// 尝试的解析器
+/// 当成功时直接返回原结果
+/// 当失败时调用resume函数处理失败结果并返回成功结果
+/// </summary>
+/// <param name="parser">上游解析器</param>
+/// <param name="resume">处理失败结果的恢复函数</param>
+/// <typeparam name="TToken">输入流令牌</typeparam>
+/// <typeparam name="T">解析器返回结果类型</typeparam>
+internal sealed class TryParser<TToken, T>(Parser<TToken, T> parser, Func<FailedResult<TToken, T>, T> resume)
+    : ModifiedParser<TToken, T, T>(parser)
+{
+    protected override ParseResult<TToken, T> Succeed<TState>(TState state,
+        SuccessfulResult<TToken, T> successfulResult)
+        => successfulResult;
+
+    protected override ParseResult<TToken, T> Fail<TState>(TState state, FailedResult<TToken, T> failedResult)
+        => ParseResultBuilder.Succeed<TToken, TState, T>(resume(failedResult), state);
+}

CanonSharp.Combinator/Parsers/PrimitiveParser.cs

@@ -0,0 +1,25 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers;
+
+/// <summary>
+/// 解析器原型基类
+/// 实际上就是处理了一个后继调用
+/// </summary>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析结果的类型</typeparam>
+public abstract class PrimitiveParser<TToken, T> : Parser<TToken, T>
+{
+    /// <summary>
+    /// 运行解析器 返回解析结果
+    /// </summary>
+    /// <param name="state">当前输入流的状态</param>
+    /// <typeparam name="TState">输入流状态的类型</typeparam>
+    /// <returns>解析结果</returns>
+    protected abstract ParseResult<TToken, T> Run<TState>(TState state)
+        where TState : IReadState<TToken, TState>;
+
+    internal sealed override ParseResult<TToken, TResult> Run<TState, TResult>(TState state,
+        Func<ParseResult<TToken, T>, ParseResult<TToken, TResult>> continuation)
+        => continuation(Run(state));
+}

CanonSharp.Combinator/Parsers/Primitives/FailedParser.cs

@@ -0,0 +1,51 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Primitives;
+
+/// <summary>
+/// 直接失败的解析器
+/// </summary>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析结果的类型</typeparam>
+internal sealed class FailedParser<TToken, T> : PrimitiveParser<TToken, T>
+{
+    protected override ParseResult<TToken, T> Run<TState>(TState state)
+        => ParseResultBuilder.Fail<TToken, TState, T>(state);
+}
+
+/// <summary>
+/// 含有失败信息的失败解析器
+/// </summary>
+/// <param name="message">失败信息</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析结果的类型</typeparam>
+internal sealed class FailedParserWithMessage<TToken, T>(string message) : PrimitiveParser<TToken, T>
+{
+    protected override ParseResult<TToken, T> Run<TState>(TState state)
+        => ParseResultBuilder.Fail<TToken, TState, T>(message, state);
+}
+
+/// <summary>
+/// 按照输入状态产生失败信息的失败解析器
+/// </summary>
+/// <param name="messageFunc">产生失败信息的函数</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析结果的类型</typeparam>
+internal sealed class FailedParserWithDelayedMessage<TToken, T>(Func<IReadState<TToken>, string> messageFunc)
+    : PrimitiveParser<TToken, T>
+{
+    protected override ParseResult<TToken, T> Run<TState>(TState state)
+        => ParseResultBuilder.Fail<TToken, TState, T>(messageFunc(state), state);
+}
+
+/// <summary>
+/// 含有失败异常的失败解析器
+/// </summary>
+/// <param name="e">异常</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析结果的类型</typeparam>
+internal sealed class FailedParserWithException<TToken, T>(Exception e) : PrimitiveParser<TToken, T>
+{
+    protected override ParseResult<TToken, T> Run<TState>(TState state)
+        => ParseResultBuilder.Fail<TToken, TState, T>(e, state);
+}

CanonSharp.Combinator/Parsers/Primitives/PureParser.cs

@@ -0,0 +1,27 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Primitives;
+
+/// <summary>
+/// 直接成功的解析器
+/// </summary>
+/// <param name="value">解析成功返回的值</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析成功返回值的类型</typeparam>
+internal sealed class PureParser<TToken, T>(T value) : PrimitiveParser<TToken, T>
+{
+    protected override ParseResult<TToken, T> Run<TState>(TState state)
+        => ParseResultBuilder.Succeed<TToken, TState, T>(value, state);
+}
+
+/// <summary>
+/// 按照输入状态返回结果的始终成功解析器
+/// </summary>
+/// <param name="valueFunc">按照输入状态返回解析结果的函数</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+/// <typeparam name="T">解析成功返回值的类型</typeparam>
+internal sealed class DelayedPureParser<TToken, T>(Func<IReadState<TToken>, T> valueFunc) : PrimitiveParser<TToken, T>
+{
+    protected override ParseResult<TToken, T> Run<TState>(TState state)
+        => ParseResultBuilder.Succeed<TToken, TState, T>(valueFunc(state), state);
+}

CanonSharp.Combinator/Parsers/Primitives/SatisfyParser.cs

@@ -0,0 +1,18 @@
+using CanonSharp.Combinator.Abstractions;
+
+namespace CanonSharp.Combinator.Parsers.Primitives;
+
+/// <summary>
+/// 满足指定条件即成功的解析器
+/// </summary>
+/// <param name="predicate">满足的条件谓词</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+internal sealed class SatisfyParser<TToken>(Func<TToken, bool> predicate) : PrimitiveParser<TToken, TToken>
+{
+    protected override ParseResult<TToken, TToken> Run<TState>(TState state)
+    {
+        return state.HasValue && predicate(state.Current)
+            ? ParseResultBuilder.Succeed<TToken, TState, TToken>(state.Current, state.Next)
+            : ParseResultBuilder.Fail<TToken, TState, TToken>(state);
+    }
+}

CanonSharp.Combinator/Parsers/Primitives/SkipParser.cs

@@ -0,0 +1,22 @@
+using CanonSharp.Combinator.Abstractions;
+using CanonSharp.Combinator.Extensions;
+
+namespace CanonSharp.Combinator.Parsers.Primitives;
+
+/// <summary>
+/// 跳过指定数量的输入令牌
+/// </summary>
+/// <param name="count">需要跳过的令牌数量</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+internal sealed class SkipParser<TToken>(int count) : PrimitiveParser<TToken, Unit>
+{
+    protected override ParseResult<TToken, Unit> Run<TState>(TState state)
+    {
+        List<TState> result = state.AsEnumerable<TToken, TState>().Take(count).ToList();
+
+        return result.Count == count
+            ? ParseResultBuilder.Succeed<TToken, TState, Unit>(Unit.Instance,
+                result.Count == 0 ? state : result.Last().Next)
+            : ParseResultBuilder.Fail<TToken, TState, Unit>("An input does not have required length.", state);
+    }
+}

CanonSharp.Combinator/Parsers/Primitives/TakeParser.cs

@@ -0,0 +1,23 @@
+using CanonSharp.Combinator.Abstractions;
+using CanonSharp.Combinator.Extensions;
+
+namespace CanonSharp.Combinator.Parsers.Primitives;
+
+/// <summary>
+/// 解析指定数量的解析器
+/// </summary>
+/// <param name="count">需要解析的数量</param>
+/// <typeparam name="TToken">输入流类型</typeparam>
+internal sealed class TakeParser<TToken>(int count) : PrimitiveParser<TToken, IEnumerable<TToken>>
+{
+    protected override ParseResult<TToken, IEnumerable<TToken>> Run<TState>(TState state)
+    {
+        List<TState> result = state.AsEnumerable<TToken, TState>().Take(count).ToList();
+
+        return result.Count == count
+            ? ParseResultBuilder.Succeed<TToken, TState, IEnumerable<TToken>>(result.Select(s => s.Current),
+                result.Count == 0 ? state : result.Last().Next)
+            : ParseResultBuilder.Fail<TToken, TState, IEnumerable<TToken>>("An input does not have required length.",
+                state);
+    }
+}