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