CanonSharp/CanonSharp.Combinator/Abstractions/FailedResult.cs

namespace CanonSharp.Combinator.Abstractions;

/// <summary>
/// 失败解析结果基类
/// </summary>
/// <typeparam name="TToken">输入流类型</typeparam>
/// <typeparam name="T">解析结果类型</typeparam>
public abstract class FailedResult<TToken, T> : ParseResult<TToken, T>
{
    public override T Value => throw Exception;

    /// <summary>
    /// 当前读取到的状态
    /// </summary>
    public abstract IReadState<TToken> State { get; }

    /// <summary>
    /// 解析失败的消息
    /// </summary>
    public abstract string Message { get; }

    /// <summary>
    /// 解析失败的异常
    /// </summary>
    public virtual ParseException Exception => new(ToString());

    /// <summary>
    /// 转换该失败结果的类型
    /// </summary>
    /// <typeparam name="TNext">转换之后的结果类型</typeparam>
    /// <returns>转换之后的失败解析类型</returns>
    public abstract FailedResult<TToken, TNext> Convert<TNext>();

    internal override ParseResult<TToken, TResult> Next<TNext, TResult>(Func<T, Parser<TToken, TNext>> nextParser,
        Func<ParseResult<TToken, TNext>, ParseResult<TToken, TResult>> continuation)
        => continuation(Convert<TNext>());

    public override ParseResult<TToken, TResult> Map<TResult>(Func<T, TResult> map)
        => Convert<TResult>();

    public override TResult CaseOf<TResult>(Func<SuccessfulResult<TToken, T>, TResult> successfulHandler,
        Func<FailedResult<TToken, T>, TResult> failedHandler)
        => failedHandler(this);

    public override string ToString()
    {
        return $"Parse Failed: {Message}.";
    }
}