back to the roots

Author: nikandfor

README.md

@@ -7,44 +7,15 @@
 
 # errors
 
-Stdlib `errors` package extension. `go1.13` `errors.Is` and `errors.As` are the same functions as in stdlib (not even copies).
+`errors` is a wrapper around the standard `errors.New` and `fmt.Errorf` functions.
+It unifies their APIs, allowing you to create new errors or wrap existing ones with rich context (formatted message with arguments).
 
-```go
-// as usual
-err = errors.New("msg")
+It provides two core functions:
 
-// do not capture caller info
-err = errors.NewNoLoc("msg")
-
-// fmt.Sprintf like
-err = errors.New("message %v", "args")
-
-// one Frame higher
-err = errors.NewDepth(1, "msg")
-
-// the same result as previous
-pc := loc.Caller(1)
-err = errors.NewLoc(pc, "msg")
-
-// Wrap error
-err = errors.Wrap(err, "msg %v", "args")
-
-// all the same function types are available
-err = errors.WrapNoLoc(err, "msg")
-
-err = errors.WrapDepth(err, 1, "msg %v", "args")
-
-err = errors.WrapLoc(err, pc, "msg %v", "args")
 ```
-
-## Caller
-
-Caller frame can be added to error so later you can get to know where error was generated. It's added by default and captures instruction calling `errors.(Wrap|New)*`.
-
-Caller is moved to a separate module [tlog.app/go/loc](https://github.com/tlog-dev/loc).
-
-```go
-pc := loc.Caller(1)
-
-pc = loc.FuncEntry(1)
+errors.New(format string, args ...any) error
+errors.Wrap(err error, format string, args ...any) error
 ```
+
+While it previously had more features, I eventually realized that,
+in most cases, anything beyond simple error wrapping is an overcomplication.

errors.go

@@ -0,0 +1,46 @@
+// errors is a tiny stdlib errors wrapper.
+// All it does changes the api from New(msg string) and fmt.Errorf(format string, args ...any) to New(format string, args ...any).
+package errors
+
+import (
+	"errors"
+	"fmt"
+)
+
+type (
+	wrap struct {
+		err error
+		msg string
+	}
+)
+
+func Is(err, target error) bool     { return errors.Is(err, target) }
+func As(err error, target any) bool { return errors.As(err, target) }
+func Unwrap(err error) error        { return errors.Unwrap(err) }
+
+func New(format string, args ...any) error {
+	if args == nil {
+		return errors.New(format)
+	}
+
+	return fmt.Errorf(format, args...)
+}
+
+func Wrap(err error, format string, args ...any) error {
+	if err == nil {
+		panic("wrapping nil error")
+	}
+
+	return &wrap{
+		err: err,
+		msg: fmt.Sprintf(format, args...),
+	}
+}
+
+func (w *wrap) Error() string {
+	return fmt.Sprintf("%v: %v", w.msg, w.err)
+}
+
+func (w *wrap) Unwrap() error {
+	return w.err
+}