Implement ops.Unwrap{Option|Result}

Author: BooleanCat

iter/filters/filters.go

@@ -2,23 +2,31 @@ package filters
 
 import "constraints"
 
+// IsZero is a filter intended for use with iter.Filter that returns true when
+// the provided value is equal to its zero value.
 func IsZero[T comparable](t T) bool {
 	var u T
 	return t == u
 }
 
+// GreaterThan creates a filter for use with iter.Filter that returns true when
+// a value is greater than the provided threshold.
 func GreaterThan[T constraints.Ordered](t T) func(T) bool {
 	return func(s T) bool {
 		return s > t
 	}
 }
 
+// LessThan creates a filter for use with iter.Filter that returns true when a
+// value is less than the provided threshold.
 func LessThan[T constraints.Ordered](t T) func(T) bool {
 	return func(s T) bool {
 		return s < t
 	}
 }
 
+// And aggregates multiple filters for use with iter.Filter (and iter.Exclude)
+// to create a filter that returns true when all provided filters return true.
 func And[T constraints.Ordered](filters ...func(T) bool) func(T) bool {
 	return func(t T) bool {
 		for _, filter := range filters {

iter/ops/ops.go

@@ -0,0 +1,18 @@
+package ops
+
+import (
+	"github.com/BooleanCat/go-functional/option"
+	"github.com/BooleanCat/go-functional/result"
+)
+
+// UnwrapOption may be used as an operation for iter.Map in order to unwrap
+// all options in an iterator.
+func UnwrapOption[T any](o option.Option[T]) T {
+	return o.Unwrap()
+}
+
+// UnwrapResult may be used as an operation for iter.Map in order to unwrap
+// all results in an iterator.
+func UnwrapResult[T any](r result.Result[T]) T {
+	return r.Unwrap()
+}

iter/ops/ops_test.go

@@ -0,0 +1,71 @@
+package ops_test
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/BooleanCat/go-functional/internal/assert"
+	"github.com/BooleanCat/go-functional/iter"
+	"github.com/BooleanCat/go-functional/iter/ops"
+	"github.com/BooleanCat/go-functional/option"
+	"github.com/BooleanCat/go-functional/result"
+)
+
+func TestUnwrapOption(t *testing.T) {
+	options := iter.Lift([]option.Option[int]{
+		option.Some(4),
+		option.Some(6),
+		option.Some(-1),
+	})
+
+	integers := iter.Map[option.Option[int]](options, ops.UnwrapOption[int])
+
+	assert.SliceEqual(t, iter.Collect[int](integers), []int{4, 6, -1})
+}
+
+func TestUnwrapOptionPanic(t *testing.T) {
+	defer func() {
+		assert.Equal(t, fmt.Sprint(recover()), "called `Option.Unwrap()` on a `None` value")
+	}()
+
+	iter.Collect[int](
+		iter.Map[option.Option[int]](
+			iter.Lift(
+				[]option.Option[int]{option.None[int]()},
+			),
+			ops.UnwrapOption[int],
+		),
+	)
+
+	t.Error("did not panic")
+}
+
+func TestUnwrapResult(t *testing.T) {
+	results := iter.Lift([]result.Result[int]{
+		result.Ok(4),
+		result.Ok(6),
+		result.Ok(-1),
+	})
+
+	integers := iter.Map[result.Result[int]](results, ops.UnwrapResult[int])
+
+	assert.SliceEqual(t, iter.Collect[int](integers), []int{4, 6, -1})
+}
+
+func TestUnwrapResultPanic(t *testing.T) {
+	defer func() {
+		assert.Equal(t, fmt.Sprint(recover()), "called `Result.Unwrap()` on an `Err` value")
+	}()
+
+	iter.Collect[int](
+		iter.Map[result.Result[int]](
+			iter.Lift(
+				[]result.Result[int]{result.Err[int](errors.New("oops"))},
+			),
+			ops.UnwrapResult[int],
+		),
+	)
+
+	t.Error("did not panic")
+}