add test/example for Catch fmt & bug fix

Author: lainio

README.md

@@ -25,7 +25,7 @@ func CopyFile(src, dst string) (err error) {
 		return fmt.Errorf("mixing traditional error checking: %w", err)
 	}
 	defer err2.Handle(&err, err2.Err(func(error) {
-		os.Remove(dst)
+		try.Out1(os.Remove(dst)).Logf("cleaning error")
 	}))
 	defer w.Close()
 	try.To1(io.Copy(w, r))
@@ -430,30 +430,34 @@ Please see the full version history from [CHANGELOG](./CHANGELOG.md).
 ### Latest Release
 
 ##### 0.9.40
-- Huge performance boost for: `defer err2.Handle/Catch()` 
+- Significant performance boost for: `defer err2.Handle/Catch()` 
   - **3x faster happy path than the previous version, which is now equal to
-    simplest `defer` function in the err-returning function** . (Please see the
-    `defer` benchmarks in the `err2_test.go` and run `make bench_reca`)
+    simplest `defer` function in the `err`-returning function** . (Please see
+    the `defer` benchmarks in the `err2_test.go` and run `make bench_reca`)
   - the solution caused a change to API, where the core reason is Go's
     optimization "bug". (We don't have confirmation yet)
 - Changed API for deferred error handling: `defer err2.Handle/Catch()`
-  - deprecated:
+  - Deprecated:
     ```go
-    defer err2.Handle(&err, func() { // THE OLD, deprecated API
-    defer err2.Handle(&err, func(error) error { // The New CURRENT API
+    defer err2.Handle(&err, func() { // <- relaying closure to access err val
     ```
-  - added:
+  - Current version:
+    ```go
+    defer err2.Handle(&err, func(error) error { // <- err val goes thru
+    ```
+  - Added a new API:
     ```go
     defer err2.Handle(&err, func(noerr bool) {
             assert.That(noerr) // noerr is always true!!
             doSomething()
     })
     ```
+- Bug fixes: `ResultX.Logf()` now works as it should
 - More documentation
 
 ### Upcoming releases
 
 ##### 0.9.5
-- Go's standard lib's flag pkg integration (similar to `glog`)
+- Idea: Go's standard lib's flag pkg integration (similar to `glog`)
 - Continue removing unused parts from `assert` pkg
 - More documentation, repairing for some sort of marketing

err2_test.go

@@ -398,6 +398,21 @@ func TestSetErrorTracer(t *testing.T) {
 	test.Require(t, w == nil, "error tracer should be nil")
 }
 
+func ExampleCatch_withFmt() {
+	// Set default logger to stdout for this example
+	oldLogW := err2.LogTracer()
+	err2.SetLogTracer(os.Stdout)
+	defer err2.SetLogTracer(oldLogW)
+
+	transport := func() {
+		// See how Catch follows given format string similarly as Handle
+		defer err2.Catch("catch")
+		err2.Throwf("our error")
+	}
+	transport()
+	// Output: catch: our error
+}
+
 func ExampleHandle() {
 	var err error
 	defer err2.Handle(&err)

internal/handler/handler.go

@@ -138,6 +138,7 @@ func (i *Info) workError() (err error) {
 
 func (i *Info) fmtErr() {
 	*i.Err = fmt.Errorf(i.Format+i.wrapStr(), append(i.Args, i.werr)...)
+	i.werr = *i.Err // remember change both our errors!
 }
 
 func (i *Info) buildFmtErr() {

samples/main-db-sample.go

@@ -9,23 +9,23 @@ import (
 	"github.com/lainio/err2/try"
 )
 
-// TODO: test migrations with these samples!
-
 func (db *Database) MoneyTransfer(from, to *Account, amount int) (err error) {
 	defer err2.Handle(&err)
 
 	tx := try.To1(db.BeginTransaction())
-	defer err2.Handle(&err, func() {
+	defer err2.Handle(&err, func(err error) error {
 		if errRoll := tx.Rollback(); errRoll != nil {
 			// with go 1.20: err = fmt.Errorf("%w: ROLLBACK ERROR: %w", err, errRoll)
 			err = fmt.Errorf("%v: ROLLBACK ERROR: %w", err, errRoll)
 		}
+		return err
 	})
 
 	try.To(from.ReserveBalance(tx, amount))
 
-	defer err2.Handle(&err, func() { // optional, following sample's wording
+	defer err2.Handle(&err, func(err error) error { // optional, following sample's wording
 		err = fmt.Errorf("cannot %w", err)
+		return err
 	})
 
 	try.To(from.Withdraw(tx, amount))

samples/main-play.go

@@ -27,8 +27,9 @@ func CopyFile(src, dst string) (err error) {
 	defer r.Close()
 
 	w := try.To1(os.Create(dst))
-	defer err2.Handle(&err, func() {
+	defer err2.Handle(&err, func(err error) error {
 		try.Out(os.Remove(dst)).Logf()
+		return err
 	})
 	defer w.Close()
 
@@ -55,8 +56,9 @@ func OrgCopyFile(src, dst string) (err error) {
 	if err != nil {
 		return fmt.Errorf("mixing traditional error checking: %w", err)
 	}
-	defer err2.Handle(&err, func() {
+	defer err2.Handle(&err, func(err error) error {
 		try.Out(os.Remove(dst)).Logf("cleaning error")
+		return err
 	})
 	defer w.Close()
 	try.To1(io.Copy(w, r))

scripts/README.md

@@ -11,10 +11,13 @@ functions or make something obsolete.
 
 ### `err2.Catch(func() {})` -> `err2.Catch(func(error) error {})` and others in v0.9.40
 
-The version 0.9.40 has major update because of the performance. We have managed
-to eliminate `defer` slowdown. Our benchmarks are 3x faster and about equal to
-those function call stacks (100 level) that don't use `defer`. And because
-`try.To` is already as fast as `if err != nil` we reached our goal in speedwise!
+The version 0.9.40 is a major update because of the performance. We have managed
+to eliminate `defer` slowdown. Our benchmarks are 3x faster than previous
+version and about equal to those function call stacks (100 level) that don't use
+`defer`. We are exactly at the same level of performance with those functions
+that use deferred function that accept an argument. Transporting an argument to
+deferred function seems to be slower than functions that don't. And because
+`try.To` is already as fast as `if err != nil` we reached our goal for speed!
 
 Because all of the error handler function signatures are now:
 ```go