使用 Panic 进行多级返回：Go 语言中的递归解析器优化

package main

import (
    "fmt"
    "runtime"
)

type ParseError struct {
    Message string
    File    string
    Line    int
}

func (e ParseError) Error() string {
    return fmt.Sprintf("%s:%d: %s", e.File, e.Line, e.Message)
}

func parse(input string) (interface{}, error) {
    defer func() {
        if r := recover(); r != nil {
            // 获取panic发生时的堆栈信息
            pc, file, line, ok := runtime.Caller(3)
            if !ok {
                file = "unknown"
            }

            // 将panic转化为error
            err, ok := r.(error)
            if !ok {
                err = fmt.Errorf("panic: %v", r)
            }

            // 包装error信息
            panic(ParseError{
                Message: err.Error(),
                File:    file,
                Line:    line,
            })
        }
    }()

    return parseInternal(input)
}

func parseInternal(input string) (interface{}, error) {
    // 模拟解析过程中遇到的错误
    if len(input) == 0 {
        panic(fmt.Errorf("unexpected end of input"))
    }

    // 模拟一些解析逻辑
    if input[0] == 'a' {
        return "parsed A", nil
    } else {
        // 递归调用
        return parseInternal(input[1:])
    }
}

func main() {
    result, err := parse("bcdef")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}