empty Catch default is logging now as try.Out().Logf()

Author: lainio

err2.go

@@ -103,10 +103,10 @@ func Handle(err *error, a ...any) {
 //
 // The deferred Catch is very convenient, because it makes your current
 // goroutine panic and error-safe, one line only! You can fine tune its
-// behavior with functions like err2.SetErrorTrace, assert.SetDefault, etc.
-// Start with the defaults.
+// behavior with functions like err2.SetErrorTrace, assert.SetDefault, and
+// logging settings. Start with the defaults and simplest version of Catch:
 //
-//	defer err2.Catch()
+//	defer err2.Catch() // writes errors to logs and panic traces to stderr
 //
 // Catch support logging as well:
 //
@@ -147,7 +147,7 @@ func Catch(a ...any) {
 	err = handler.PreProcess(&err, &handler.Info{
 		CallerName: "Catch",
 		Any:        r,
-		NilHandler: handler.NilNoop,
+		// NilHandler: handler.NilNoop, // TODO: why this is here?
 	}, a...)
 	doTrace(err)
 }

err2_test.go

@@ -1,9 +1,11 @@
 package err2_test
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
+	"runtime"
 	"testing"
 
 	"github.com/lainio/err2"
@@ -898,6 +900,46 @@ func BenchmarkRecursionWithTryAnd_Empty_Defer(b *testing.B) {
 	}
 }
 
+func doWork(ePtr *error, r any) {
+	switch v := r.(type) {
+	case nil:
+		return
+	case runtime.Error:
+		*ePtr = errors.Join(v, *ePtr)
+	case error:
+		*ePtr = errors.Join(v, *ePtr)
+	default:
+		// panicing
+	}
+}
+
+func BenchmarkRecursionWithTryAnd_HeavyPtrPtr_Defer(b *testing.B) {
+	var recursion func(a int) (r int, err error)
+	recursion = func(a int) (r int, err error) {
+		defer func(ePtr *error) {
+			r := recover()
+			nothingToDo := r == nil && (ePtr == nil || *ePtr == nil)
+			if nothingToDo {
+				return
+			}
+			doWork(ePtr, r)
+		}(&err)
+
+		if a == 0 {
+			return 0, nil
+		}
+		s := try.To1(noThrow())
+		_ = s
+		r = try.To1(recursion(a - 1))
+		r += a
+		return r, nil
+	}
+
+	for n := 0; n < b.N; n++ {
+		_, _ = recursion(100)
+	}
+}
+
 func BenchmarkRecursionWithTryAndDefer(b *testing.B) {
 	var recursion func(a int) (r int, err error)
 	recursion = func(a int) (r int, err error) {

internal/handler/handler.go

@@ -267,7 +267,7 @@ func PreProcess(errPtr *error, info *Info, a ...any) error {
 	if len(a) > 0 {
 		subProcess(info, a...)
 	} else {
-		fnName := "Handle"
+		fnName := "Handle" // default
 		if info.CallerName != "" {
 			fnName = info.CallerName
 		}
@@ -292,8 +292,7 @@ func PreProcess(errPtr *error, info *Info, a ...any) error {
 
 	Process(info)
 
-	logCatchCallMode := defCatchCallMode && firstArgIsString(a...)
-	if curErr := info.safeErr(); logCatchCallMode && curErr != nil {
+	if curErr := info.safeErr(); defCatchCallMode && curErr != nil {
 		_, _, frame, ok := debug.FuncName(debug.StackInfo{
 			PackageName: "",
 			FuncName:    "Catch",
@@ -308,7 +307,8 @@ func PreProcess(errPtr *error, info *Info, a ...any) error {
 	return err
 }
 
-func firstArgIsString(a ...any) bool {
+// firstArgIsString not used any more.
+func _(a ...any) bool {
 	if len(a) > 0 {
 		_, isStr := a[0].(string)
 		return isStr