fix: try a more efficient implementation of standard interfaces

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>

either/core.go

@@ -20,31 +20,43 @@ import (
 )
 
 type (
-	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
-	Either[E, A any] struct {
+	either struct {
 		isLeft bool
 		value  any
 	}
+
+	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
+	Either[E, A any] either
 )
 
 // String prints some debug info for the object
-func (s Either[E, A]) String() string {
+func eitherString(s *either) string {
 	if s.isLeft {
 		return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
 	}
 	return fmt.Sprintf("Right[%T](%v)", s.value, s.value)
 }
 
 // Format prints some debug info for the object
-func (s Either[E, A]) Format(f fmt.State, c rune) {
+func eitherFormat(e *either, f fmt.State, c rune) {
 	switch c {
 	case 's':
-		fmt.Fprint(f, s.String())
+		fmt.Fprint(f, eitherString(e))
 	default:
-		fmt.Fprint(f, s.String())
+		fmt.Fprint(f, eitherString(e))
 	}
 }
 
+// String prints some debug info for the object
+func (s Either[E, A]) String() string {
+	return eitherString((*either)(&s))
+}
+
+// Format prints some debug info for the object
+func (s Either[E, A]) Format(f fmt.State, c rune) {
+	eitherFormat((*either)(&s), f, c)
+}
+
 // IsLeft tests if the [Either] is a left value. Rather use [Fold] if you need to access the values. Inverse is [IsRight].
 func IsLeft[E, A any](val Either[E, A]) bool {
 	return val.isLeft

either/either_test.go

@@ -17,6 +17,7 @@ package either
 
 import (
 	"errors"
+	"fmt"
 	"testing"
 
 	F "github.com/IBM/fp-go/function"
@@ -109,3 +110,13 @@ func TestFromOption(t *testing.T) {
 	assert.Equal(t, Left[int]("none"), FromOption[int](F.Constant("none"))(O.None[int]()))
 	assert.Equal(t, Right[string](1), FromOption[int](F.Constant("none"))(O.Some(1)))
 }
+
+func TestStringer(t *testing.T) {
+	e := Of[error]("foo")
+	exp := "Right[string](foo)"
+
+	assert.Equal(t, exp, e.String())
+
+	var s fmt.Stringer = e
+	assert.Equal(t, exp, s.String())
+}

option/core.go

@@ -19,60 +19,80 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"reflect"
 )
 
 var (
+	// jsonNull is the cached representation of the `null` serialization in JSON
 	jsonNull = []byte("null")
 )
 
 // Option defines a data structure that logically holds a value or not
 type Option[A any] struct {
 	isSome bool
-	some   A
+	value  A
 }
 
-// String prints some debug info for the object
-func (s Option[A]) String() string {
-	if s.isSome {
-		return fmt.Sprintf("Some[%T](%v)", s.some, s.some)
+// optString prints some debug info for the object
+func optString(isSome bool, value any) string {
+	if isSome {
+		return fmt.Sprintf("Some[%T](%v)", value, value)
 	}
-	return fmt.Sprintf("None[%T]", s.some)
+	return fmt.Sprintf("None[%T]", value)
 }
 
-// Format prints some debug info for the object
-func (s Option[A]) Format(f fmt.State, c rune) {
+// optFormat prints some debug info for the object
+func optFormat(isSome bool, value any, f fmt.State, c rune) {
 	switch c {
 	case 's':
-		fmt.Fprint(f, s.String())
+		fmt.Fprint(f, optString(isSome, value))
 	default:
-		fmt.Fprint(f, s.String())
+		fmt.Fprint(f, optString(isSome, value))
 	}
 }
 
-func (s Option[A]) MarshalJSON() ([]byte, error) {
-	if IsSome(s) {
-		return json.Marshal(s.some)
+// String prints some debug info for the object
+func (s Option[A]) String() string {
+	return optString(s.isSome, s.value)
+}
+
+// Format prints some debug info for the object
+func (s Option[A]) Format(f fmt.State, c rune) {
+	optFormat(s.isSome, s.value, f, c)
+}
+
+func optMarshalJSON(isSome bool, value any) ([]byte, error) {
+	if isSome {
+		return json.Marshal(value)
 	}
 	return jsonNull, nil
 }
 
-func (s *Option[A]) UnmarshalJSON(data []byte) error {
+func (s Option[A]) MarshalJSON() ([]byte, error) {
+	return optMarshalJSON(s.isSome, s.value)
+}
+
+func optUnmarshalJSON(isSome *bool, value any, data []byte) error {
 	// decode the value
 	if bytes.Equal(data, jsonNull) {
-		s.isSome = false
-		s.some = *new(A)
+		*isSome = false
+		reflect.ValueOf(value).Elem().SetZero()
 		return nil
 	}
-	s.isSome = true
-	return json.Unmarshal(data, &s.some)
+	*isSome = true
+	return json.Unmarshal(data, value)
+}
+
+func (s *Option[A]) UnmarshalJSON(data []byte) error {
+	return optUnmarshalJSON(&s.isSome, &s.value, data)
 }
 
 func IsNone[T any](val Option[T]) bool {
 	return !val.isSome
 }
 
 func Some[T any](value T) Option[T] {
-	return Option[T]{isSome: true, some: value}
+	return Option[T]{isSome: true, value: value}
 }
 
 func Of[T any](value T) Option[T] {
@@ -89,11 +109,11 @@ func IsSome[T any](val Option[T]) bool {
 
 func MonadFold[A, B any](ma Option[A], onNone func() B, onSome func(A) B) B {
 	if IsSome(ma) {
-		return onSome(ma.some)
+		return onSome(ma.value)
 	}
 	return onNone()
 }
 
 func Unwrap[A any](ma Option[A]) (A, bool) {
-	return ma.some, ma.isSome
+	return ma.value, ma.isSome
 }