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/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);
+}