Refactor Wrap to accept only error, update tests, changelog, and imports

Author: tomas-novotny

CHANGELOG.md

@@ -6,7 +6,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 
-## [Unreleased](https://github.com/gravitton/errors/compare/v1.1.0...master)
+## [Unreleased](https://github.com/gravitton/errors/compare/v1.1.1...master)
+
+## v1.1.1 (2026-04-23)(https://github.com/gravitton/errors/compare/v1.01.0...v1.1.1)
+### Changed
+- `Wrap` now accepts only `error` instead of `any`
 
 ## v1.1.0 (2026-04-22)(https://github.com/gravitton/errors/compare/v1.0.0...v1.1.0)
 ### Added

README.md

@@ -42,8 +42,9 @@ func Process() error {
 package main
 
 import (
-	"github.com/gravitton/errors"
 	"sync"
+
+	"github.com/gravitton/errors"
 )
 
 func Process() error {

error.go

@@ -35,27 +35,24 @@ func Newf(format string, v ...any) *DataError {
 	}
 }
 
-// Wrap converts any value into a *DataError and captures the current stack
+// Wrap converts an error into a *DataError and captures the current stack
 // trace. If err is nil, Wrap returns nil. If err is already a *DataError it is
-// returned unchanged. If err implements error it is wrapped directly; otherwise
-// its string representation is used as the error message.
-func Wrap(err any) *DataError {
+// returned unchanged. Otherwise the error is wrapped directly.
+//
+// Warning: the returned *DataError nil is a typed nil pointer. When assigned to
+// or returned as an error interface it will not equal nil. Prefer checking the
+// error before passing it to Wrap rather than checking the result afterwards.
+func Wrap(err error) *DataError {
 	if err == nil {
 		return nil
 	}
 
-	var e error
-	switch t := err.(type) {
-	case *DataError:
-		return t
-	case error:
-		e = t
-	default:
-		e = fmt.Errorf("%v", err)
+	if dataErr, ok := err.(*DataError); ok {
+		return dataErr
 	}
 
 	return &DataError{
-		err:   e,
+		err:   err,
 		stack: callers(1),
 	}
 }

error_test.go

@@ -28,28 +28,20 @@ func TestNewf(t *testing.T) {
 	assert.Equal(t, reflect.TypeOf(cause).String(), "*errors.errorString")
 }
 
-func TestWrapNil(t *testing.T) {
-	err := Wrap(nil)
-
-	assert.NoError(t, err)
+func testMethod(err error) error {
+	return Wrap(err)
 }
 
-func TestWrapNonError(t *testing.T) {
-	err := Wrap("something went wrong")
-
-	assert.Equal(t, err.Error(), "something went wrong")
-
-	cause := err.Unwrap()
-	assert.Equal(t, reflect.TypeOf(cause).String(), "*errors.errorString")
-}
+func TestWrapNil(t *testing.T) {
+	err1 := Wrap(nil)
 
-func TestWrapNonErrorNonString(t *testing.T) {
-	err := Wrap(159.5)
+	assert.NoError(t, err1)
+	assert.True(t, err1 == nil)
 
-	assert.Equal(t, err.Error(), "159.5")
+	err2 := testMethod(nil)
 
-	cause := err.Unwrap()
-	assert.Equal(t, reflect.TypeOf(cause).String(), "*errors.errorString")
+	assert.NoError(t, err2)
+	assert.False(t, err2 == nil) // typed *DataError(nil) nil pointer
 }
 
 func TestWrapError(t *testing.T) {
@@ -58,7 +50,7 @@ func TestWrapError(t *testing.T) {
 
 	assert.Equal(t, err.Error(), "original")
 
-	cause := err.Unwrap()
+	cause := errors.Unwrap(err)
 	assert.Equal(t, cause, original)
 }