Go Error 嵌套到底是怎么实现的？

// src/builtin/builtin.go
type error interface {
  Error() string
}
复制代码

package main
import (
  "errors"
  "fmt"
)
func main() {
  err := errors.New("这是 errors.New() 创建的错误")
  fmt.Printf("err 错误类型：%T，错误为：%v\n", err, err)
}
/* 输出
err 错误类型：*errors.errorString，错误为：这是 errors.New() 创建的错误
*/
复制代码

// src/errors/errors.go
// New returns an error that formats as the given text.
// Each call to New returns a distinct error value even if the text is identical.
func New(text string) error {
  return &errorString{text}
}
// errorString is a trivial implementation of error.
type errorString struct {
  s string
}
func (e *errorString) Error() string {
  return e.s
}
复制代码

package main
import (
  "database/sql"
  "fmt"
)
func foo() error {
  return sql.ErrNoRows
}
func bar() error {
  return foo()
}
func main() {
  err := bar()
  if err == sql.ErrNoRows {
    fmt.Printf("data not found, %+v\n", err)
    return
  }
  if err != nil {
    fmt.Println("Unknown error")
  }
}
/* 输出
data not found, sql: no rows in result set
*/
复制代码

func foo() error {
   return fmt.Errorf("foo err, %v", sql.ErrNoRows)
}
复制代码

package main
import (
  "fmt"
)
type myError struct{}
func (e myError) Error() string {
  return "Error happended"
}
func main() {
  e1 := myError{}
  e2 := fmt.Errorf("E2: %w", e1)
  e3 := fmt.Errorf("E3: %w", e2)
  fmt.Println(e2)
  fmt.Println(e3)
}
/* output
E2: Error happended
E3: E2: Error happended
*/
复制代码

// src/fmt/errors.go
func Errorf(format string, a ...interface{}) error {
  p := newPrinter()
  p.wrapErrs = true
  p.doPrintf(format, a)
  s := string(p.buf)
  var err error
  if p.wrappedErr == nil {
    err = errors.New(s)
  } else {
    err = &wrapError{s, p.wrappedErr}
  }
  p.free()
  return err
}
复制代码

// src/fmt/errors.go
type wrapError struct {
  msg string
  err error
}
func (e *wrapError) Error() string {
  return e.msg
}
func (e *wrapError) Unwrap() error {
  return e.err
}
复制代码

// src/errors/wrap.go
func Unwrap(err error) error {
  u, ok := err.(interface {
    Unwrap() error
  })
  if !ok {
    return nil
  }
  return u.Unwrap()
}
复制代码

package main
import (
  "database/sql"
  "errors"
  "fmt"
)
func bar() error {
  if err := foo(); err != nil {
    return fmt.Errorf("bar failed: %w", foo())
  }
  return nil
}
func foo() error {
  return fmt.Errorf("foo failed: %w", sql.ErrNoRows)
}
func main() {
  err := bar()
  if errors.Is(err, sql.ErrNoRows) {
    fmt.Printf("data not found,  %+v\n", err)
    return
  }
  if err != nil {
    fmt.Println("Unknown error")
  }
}
/* output
data not found,  bar failed: foo failed: sql: no rows in result set
*/
复制代码