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