feat(examples): add p/moul/errs

examples/gno.land/p/moul/errs/errs.gno

@@ -0,0 +1,139 @@
+// Package errs provides utilities for combining multiple errors.
+// This is a simplified version of https://github.com/uber-go/multierr (MIT License),
+// adapted for the Gno programming language with a focus on core functionality
+// and idiomatic usage patterns.
+//
+// Example usage:
+//
+//	err1 := doSomething()
+//	err2 := doSomethingElse()
+//	if err := errs.Combine(err1, err2); err != nil {
+//	    return err // Returns combined errors or single error
+//	}
+package errs
+
+import (
+	"strings"
+)
+
+// multiError represents multiple errors combined into one.
+type multiError struct {
+	errors []error
+}
+
+// Error implements the error interface by returning a single-line representation
+// of all contained errors, separated by semicolons.
+func (m *multiError) Error() string {
+	if m == nil || len(m.errors) == 0 {
+		return ""
+	}
+
+	var b strings.Builder
+	first := true
+	for _, err := range m.errors {
+		if first {
+			first = false
+		} else {
+			b.WriteString("; ")
+		}
+		b.WriteString(err.Error())
+	}
+	return b.String()
+}
+
+// String returns a multi-line representation of the error.
+func (m *multiError) String() string {
+	if m == nil || len(m.errors) == 0 {
+		return ""
+	}
+
+	var b strings.Builder
+	b.WriteString("the following errors occurred:")
+	for _, err := range m.errors {
+		b.WriteString("\n -  ")
+		b.WriteString(err.Error())
+	}
+	return b.String()
+}
+
+// Errors returns the slice of underlying errors contained in this multiError.
+// Returns nil if the receiver is nil.
+func (m *multiError) Errors() []error {
+	if m == nil {
+		return nil
+	}
+	return m.errors
+}
+
+// Errors extracts the underlying errors from an error interface.
+// If the error is a multiError, it returns its contained errors.
+// If the error is nil, returns nil.
+// If the error is a regular error, returns a slice containing just that error.
+func Errors(err error) []error {
+	if err == nil {
+		return nil
+	}
+
+	if merr, ok := err.(*multiError); ok {
+		return merr.Errors()
+	}
+
+	return []error{err}
+}
+
+// Combine merges multiple errors into a single error efficiently.
+// It handles several cases:
+//   - If all input errors are nil, returns nil
+//   - If there's exactly one non-nil error, returns that error directly
+//   - If there are multiple non-nil errors, returns a multiError containing them
+func Combine(errs ...error) error {
+	nonNil := make([]error, 0, len(errs))
+	for _, err := range errs {
+		if err != nil {
+			nonNil = append(nonNil, err)
+		}
+	}
+
+	switch len(nonNil) {
+	case 0:
+		return nil
+	case 1:
+		return nonNil[0]
+	default:
+		return &multiError{errors: nonNil}
+	}
+}
+
+// Append combines two errors into a single error while preserving order.
+// It handles several cases efficiently:
+//   - If both errors are nil, returns nil
+//   - If one error is nil, returns the non-nil error
+//   - If either error is a multiError, properly combines them
+//   - If both are regular errors, creates a new multiError
+func Append(err1, err2 error) error {
+	switch {
+	case err1 == nil:
+		return err2
+	case err2 == nil:
+		return err1
+	}
+
+	// If err1 is already a multiError, append to it
+	if m, ok := err1.(*multiError); ok {
+		newErrs := make([]error, len(m.errors), len(m.errors)+1)
+		copy(newErrs, m.errors)
+		newErrs = append(newErrs, err2)
+		return &multiError{errors: newErrs}
+	}
+
+	// If err2 is a multiError, prepend err1 to it
+	if m, ok := err2.(*multiError); ok {
+		newErrs := make([]error, 1, len(m.errors)+1)
+		newErrs[0] = err1
+		newErrs = append(newErrs, m.errors...)
+		return &multiError{errors: newErrs}
+	}
+
+	// Neither is a multiError
+	return &multiError{errors: []error{err1, err2}}
+}

examples/gno.land/p/moul/errs/errs_test.gno

@@ -0,0 +1,238 @@
+package errs
+
+import (
+	"testing"
+)
+
+// testError is a simple error implementation for testing
+type testError struct {
+	msg string
+}
+
+func (e *testError) Error() string {
+	return e.msg
+}
+
+func newError(msg string) error {
+	return &testError{msg: msg}
+}
+
+func TestCombine(t *testing.T) {
+	tests := []struct {
+		name     string
+		errors   []error
+		expected string
+	}{
+		{
+			name:     "nil errors",
+			errors:   []error{nil, nil},
+			expected: "",
+		},
+		{
+			name:     "single error",
+			errors:   []error{newError("error1"), nil},
+			expected: "error1",
+		},
+		{
+			name:     "multiple errors",
+			errors:   []error{newError("error1"), newError("error2"), newError("error3")},
+			expected: "error1; error2; error3",
+		},
+		{
+			name:     "mixed nil and non-nil",
+			errors:   []error{nil, newError("error1"), nil, newError("error2")},
+			expected: "error1; error2",
+		},
+	}
+
+	for _, tt := range tests {
+		err := Combine(tt.errors...)
+		if tt.expected == "" {
+			if err != nil {
+				t.Errorf("%s: expected nil error, got %v", tt.name, err)
+			}
+			continue
+		}
+
+		if err == nil {
+			t.Errorf("%s: expected non-nil error", tt.name)
+			continue
+		}
+
+		if got := err.Error(); got != tt.expected {
+			t.Errorf("%s: expected %q, got %q", tt.name, tt.expected, got)
+		}
+	}
+}
+
+func TestAppend(t *testing.T) {
+	tests := []struct {
+		name     string
+		err1     error
+		err2     error
+		expected string
+	}{
+		{
+			name:     "both nil",
+			err1:     nil,
+			err2:     nil,
+			expected: "",
+		},
+		{
+			name:     "first nil",
+			err1:     nil,
+			err2:     newError("error2"),
+			expected: "error2",
+		},
+		{
+			name:     "second nil",
+			err1:     newError("error1"),
+			err2:     nil,
+			expected: "error1",
+		},
+		{
+			name:     "both non-nil",
+			err1:     newError("error1"),
+			err2:     newError("error2"),
+			expected: "error1; error2",
+		},
+	}
+
+	for _, tt := range tests {
+		err := Append(tt.err1, tt.err2)
+		if tt.expected == "" {
+			if err != nil {
+				t.Errorf("%s: expected nil error, got %v", tt.name, err)
+			}
+			continue
+		}
+
+		if err == nil {
+			t.Errorf("%s: expected non-nil error", tt.name)
+			continue
+		}
+
+		if got := err.Error(); got != tt.expected {
+			t.Errorf("%s: expected %q, got %q", tt.name, tt.expected, got)
+		}
+	}
+}
+
+func TestErrors(t *testing.T) {
+	err1 := newError("error1")
+	err2 := newError("error2")
+	combined := Combine(err1, err2)
+
+	tests := []struct {
+		name          string
+		err           error
+		expectedCount int
+	}{
+		{
+			name:          "nil error",
+			err:           nil,
+			expectedCount: 0,
+		},
+		{
+			name:          "single error",
+			err:           err1,
+			expectedCount: 1,
+		},
+		{
+			name:          "multiple errors",
+			err:           combined,
+			expectedCount: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		errs := Errors(tt.err)
+		if len(errs) != tt.expectedCount {
+			t.Errorf("%s: expected %d errors, got %d", tt.name, tt.expectedCount, len(errs))
+		}
+	}
+}
+
+func TestMultiErrorString(t *testing.T) {
+	tests := []struct {
+		name     string
+		errors   []error
+		expected string
+	}{
+		{
+			name:     "nil errors",
+			errors:   nil,
+			expected: "",
+		},
+		{
+			name:     "empty errors",
+			errors:   []error{},
+			expected: "",
+		},
+		{
+			name:     "single error",
+			errors:   []error{newError("error1")},
+			expected: "the following errors occurred:\n -  error1",
+		},
+		{
+			name:     "multiple errors",
+			errors:   []error{newError("error1"), newError("error2")},
+			expected: "the following errors occurred:\n -  error1\n -  error2",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			merr := &multiError{errors: tt.errors}
+			if got := merr.String(); got != tt.expected {
+				t.Errorf("multiError.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestAppendEdgeCases(t *testing.T) {
+	err1 := newError("error1")
+	err2 := newError("error2")
+	err3 := newError("error3")
+
+	// Create a multiError
+	merr := Combine(err1, err2)
+
+	tests := []struct {
+		name     string
+		err1     error
+		err2     error
+		expected string
+	}{
+		{
+			name:     "append to multiError",
+			err1:     merr,
+			err2:     err3,
+			expected: "error1; error2; error3",
+		},
+		{
+			name:     "prepend to multiError",
+			err1:     err3,
+			err2:     merr,
+			expected: "error3; error1; error2",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := Append(tt.err1, tt.err2)
+			if got := err.Error(); got != tt.expected {
+				t.Errorf("Append() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestErrorsNilReceiver(t *testing.T) {
+	var merr *multiError
+	errs := merr.Errors()
+	if errs != nil {
+		t.Errorf("Expected nil slice for nil receiver, got %v", errs)
+	}
+}

examples/gno.land/p/moul/errs/gno.mod

@@ -0,0 +1 @@
+module gno.land/p/moul/errs