feat: add Close functions

This change adds a `Close` function to both the `maybe` and `result` packages.
These funcitions call the Close method on their encapsulated values if there is
a value and that value implements `io.Closer`. These are convience functions
that could be implemented by users but are so common as to warrent inclusion.

An `As` function is also added to the `maybe` package to mirror the `result`
package's `As` function.

Signed-off-by: m-d-key <[email protected]>

Author: m-d-key

pkg/maybe/maybe.go

@@ -3,6 +3,10 @@
 
 package maybe
 
+import (
+	"io"
+)
+
 // Getter defines a function that gets the default value for a Maybe that
 // encapsulates an absent value.
 type Getter[T any] func() T
@@ -24,6 +28,37 @@ type Maybe[T any] interface {
 	OrElseGet(getter Getter[T]) T
 }
 
+// As encapsulates the value in the given Maybe in a new Maybe of the target
+// type. If the given Maybe encapsulates nothing, or the encapsulated value does
+// not implement the requested type, then a Nothing Maybe will be returned of
+// the target type.
+func As[T, S any](src Maybe[S]) Maybe[T] {
+	if !src.IsJust() {
+		return Nothing[T]()
+	}
+	var v any = src.MustGet()
+	val, ok := v.(T)
+	if !ok {
+		return Nothing[T]()
+	}
+	return Just(val)
+}
+
+// Close calls close on the encapsulated value if that value implements
+// io.Closer. It is a no-op if the value encapsulates nothing or if the
+// encasuplated value does not implement io.Closer.
+func Close[T any](src Maybe[T]) error {
+	if !src.IsJust() {
+		return nil
+	}
+	v := any(src.MustGet())
+	closer, ok := v.(io.Closer)
+	if !ok {
+		return nil
+	}
+	return closer.Close()
+}
+
 // MapperNoError defines a function with one argument of any type that returns a
 // single value.
 type MapperNoError[T, R any] func(

pkg/maybe/maybe_test.go

@@ -36,3 +36,59 @@ func Test_Just_Is_Just(t *testing.T) {
 	instance := maybe.Just(10)
 	require.True(t, maybe.IsJust(instance))
 }
+
+type named interface {
+	GetName() string
+}
+
+type instance struct{}
+
+func (i *instance) GetName() string { return "my name" }
+
+func Test_As(t *testing.T) {
+	m := maybe.Just(&instance{})
+	a := maybe.As[named](m)
+	require.True(t, a.IsJust())
+	require.Equal(t, "my name", a.MustGet().GetName())
+}
+
+func Test_As_NotSupported(t *testing.T) {
+	m := maybe.Just("string")
+	a := maybe.As[int](m)
+	require.False(t, a.IsJust())
+}
+
+func Test_As_FromNothing(t *testing.T) {
+	m := maybe.Nothing[string]()
+	a := maybe.As[int](m)
+	require.False(t, a.IsJust())
+}
+
+type closer struct {
+	called bool
+}
+
+func (c *closer) Close() error {
+	c.called = true
+	return nil
+}
+
+func Test_CloseCloser(t *testing.T) {
+	c := &closer{}
+	closerMaybe := maybe.Just(c)
+	err := maybe.Close(closerMaybe)
+	require.NoError(t, err)
+	require.True(t, c.called)
+}
+
+func Test_CloseNonCloser(t *testing.T) {
+	closerMaybe := maybe.Just(99)
+	err := maybe.Close(closerMaybe)
+	require.NoError(t, err)
+}
+
+func Test_CloseError(t *testing.T) {
+	closerMaybe := maybe.Nothing[int]()
+	err := maybe.Close(closerMaybe)
+	require.NoError(t, err)
+}

pkg/result/ok.go

@@ -3,7 +3,9 @@
 
 package result
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // Ok returns a Result encapsulating the given value.
 func Ok[T any](value T) Result[T] {
@@ -45,6 +47,7 @@ func (o *ok[T]) get() T {
 	return o.value
 }
 
+// String returns a string representation of this Result.
 func (o *ok[T]) String() string {
 	return fmt.Sprintf("{Ok: %#v}", o.value)
 }

pkg/result/result.go

@@ -4,6 +4,8 @@
 package result
 
 import (
+	"io"
+
 	"github.com/sassoftware/sas-ggdk/pkg/errors"
 	"github.com/sassoftware/sas-ggdk/pkg/maybe"
 )
@@ -59,6 +61,21 @@ func As[T, S any](src Result[S]) Result[T] {
 	return Ok(val)
 }
 
+// Close calls close on the encapsulated value if that value implements
+// io.Closer. It is a no-op if the value does not implement io.Closer or the
+// result encapsulates an error.
+func Close[T any](src Result[T]) error {
+	if src.IsError() {
+		return nil
+	}
+	v := any(src.MustGet())
+	closer, ok := v.(io.Closer)
+	if !ok {
+		return nil
+	}
+	return closer.Close()
+}
+
 // ErrorMapper defines a function that takes an error and returns an error.
 // This can be used to convert between errors or add additional context to an
 // error.

pkg/result/result_test.go

@@ -104,3 +104,32 @@ func Test_FromMaybe(t *testing.T) {
 	require.Error(t, rErr.Error())
 	require.ErrorContains(t, rErr.Error(), "failed")
 }
+
+type closer struct {
+	called bool
+}
+
+func (c *closer) Close() error {
+	c.called = true
+	return nil
+}
+
+func Test_CloseCloser(t *testing.T) {
+	c := &closer{}
+	closerResult := result.Ok(c)
+	err := result.Close(closerResult)
+	require.NoError(t, err)
+	require.True(t, c.called)
+}
+
+func Test_CloseNonCloser(t *testing.T) {
+	closerResult := result.Ok(99)
+	err := result.Close(closerResult)
+	require.NoError(t, err)
+}
+
+func Test_CloseError(t *testing.T) {
+	closerResult := result.Error[int](errors.New("failed"))
+	err := result.Close(closerResult)
+	require.NoError(t, err)
+}