And then (#41)

Add `And` + `AndThen` functions to `Option` and `Result` for in place
manipulation.

Author: Dean Karn

.github/workflows/go.yml

@@ -5,11 +5,16 @@ on:
       - master
   pull_request:
     types: [opened, edited, reopened, synchronize]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.20.x,1.19.x,1.18.x,1.17.x]
+        go-version: [1.21.x,1.20.x,1.19.x,1.18.x,1.17.x]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:

CHANGELOG.md

@@ -6,7 +6,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [5.21.3] - 2023-10-18
+## [5.23.0] - 2024-01-14
+### Added
+- `And` and `AndThen` functions to `Option` & `Result` types.
+
+## [5.22.0] - 2023-10-18
 ### Added
  - `UnwrapOr`, `UnwrapOrElse` and `UnwrapOrDefault` functions to `Option` & `Result` types.
 
@@ -82,7 +86,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Added `timext.NanoTime` for fast low level monotonic time with nanosecond precision.
 
-[Unreleased]: https://github.com/go-playground/pkg/compare/v5.22.0...HEAD
+[Unreleased]: https://github.com/go-playground/pkg/compare/v5.23.0...HEAD
+[5.23.0]: https://github.com/go-playground/pkg/compare/v5.22.0..v5.23.0
 [5.22.0]: https://github.com/go-playground/pkg/compare/v5.21.3..v5.22.0
 [5.21.3]: https://github.com/go-playground/pkg/compare/v5.21.2..v5.21.3
 [5.21.2]: https://github.com/go-playground/pkg/compare/v5.21.1..v5.21.2

values/option/option.go

@@ -93,6 +93,25 @@ func (o Option[T]) UnwrapOrDefault() T {
 	return o.value
 }
 
+// And calls the provided function with the contained value if the option is Some, returns the None value otherwise.
+func (o Option[T]) And(fn func(T) T) Option[T] {
+	if o.isSome {
+		o.value = fn(o.value)
+	}
+	return o
+}
+
+// AndThen calls the provided function with the contained value if the option is Some, returns the None value otherwise.
+//
+// This differs from `And` in that the provided function returns an Option[T] allowing changing of the Option value
+// itself.
+func (o Option[T]) AndThen(fn func(T) Option[T]) Option[T] {
+	if o.isSome {
+		return fn(o.value)
+	}
+	return o
+}
+
 // Some creates a new Option with the given values.
 func Some[T any](value T) Option[T] {
 	return Option[T]{value, true}

values/option/option_test.go

@@ -26,6 +26,19 @@ type testStructType struct {
 	Name string
 }
 
+func TestAndXXX(t *testing.T) {
+	s := Some(1)
+	Equal(t, Some(3), s.And(func(i int) int { return 3 }))
+	Equal(t, Some(3), s.AndThen(func(i int) Option[int] { return Some(3) }))
+	Equal(t, None[int](), s.AndThen(func(i int) Option[int] { return None[int]() }))
+
+	n := None[int]()
+	Equal(t, None[int](), n.And(func(i int) int { return 3 }))
+	Equal(t, None[int](), n.AndThen(func(i int) Option[int] { return Some(3) }))
+	Equal(t, None[int](), n.AndThen(func(i int) Option[int] { return None[int]() }))
+	Equal(t, None[int](), s.AndThen(func(i int) Option[int] { return None[int]() }))
+}
+
 func TestUnwraps(t *testing.T) {
 	none := None[int]()
 	PanicMatches(t, func() { none.Unwrap() }, "Option.Unwrap: option is None")

values/result/result.go

@@ -62,6 +62,25 @@ func (r Result[T, E]) UnwrapOrDefault() T {
 	return r.ok
 }
 
+// And calls the provided function with the contained value if the result is Ok, returns the Result value otherwise.
+func (r Result[T, E]) And(fn func(T) T) Result[T, E] {
+	if r.isOk {
+		r.ok = fn(r.ok)
+	}
+	return r
+}
+
+// AndThen calls the provided function with the contained value if the result is Ok, returns the Result value otherwise.
+//
+// This differs from `And` in that the provided function returns a Result[T, E] allowing changing of the Option value
+// itself.
+func (r Result[T, E]) AndThen(fn func(T) Result[T, E]) Result[T, E] {
+	if r.isOk {
+		return fn(r.ok)
+	}
+	return r
+}
+
 // Err returns the error of the result. To be used after calling IsOK()
 func (r Result[T, E]) Err() E {
 	return r.err

values/result/result_test.go

@@ -13,6 +13,19 @@ import (
 
 type myStruct struct{}
 
+func TestAndXXX(t *testing.T) {
+	ok := Ok[int, error](1)
+	Equal(t, Ok[int, error](3), ok.And(func(int) int { return 3 }))
+	Equal(t, Ok[int, error](3), ok.AndThen(func(int) Result[int, error] { return Ok[int, error](3) }))
+	Equal(t, Err[int, error](io.EOF), ok.AndThen(func(int) Result[int, error] { return Err[int, error](io.EOF) }))
+
+	err := Err[int, error](io.EOF)
+	Equal(t, Err[int, error](io.EOF), err.And(func(int) int { return 3 }))
+	Equal(t, Err[int, error](io.EOF), err.AndThen(func(int) Result[int, error] { return Ok[int, error](3) }))
+	Equal(t, Err[int, error](io.EOF), err.AndThen(func(int) Result[int, error] { return Err[int, error](io.ErrUnexpectedEOF) }))
+	Equal(t, Err[int, error](io.ErrUnexpectedEOF), ok.AndThen(func(int) Result[int, error] { return Err[int, error](io.ErrUnexpectedEOF) }))
+}
+
 func TestUnwrap(t *testing.T) {
 	er := Err[int, error](io.EOF)
 	PanicMatches(t, func() { er.Unwrap() }, "Result.Unwrap(): result is Err")