add: MayAt, TryAt and MustAt constructor for safe access slice

Author: ColaFanta

option_make.go

@@ -38,6 +38,15 @@ func MayLookUp[K comparable, T any](m map[K]T, key K) Option[T] {
 	return Some(val)
 }
 
+// MayAt attempts to retrieve an element from a slice by index, returning an Option.
+// Arrays can be passed as arr[:].
+func MayAt[T any](x []T, index int) Option[T] {
+	if index < 0 || index >= len(x) {
+		return None[T]()
+	}
+	return Some(x[index])
+}
+
 // MaybeEmpty builds a Some Option when val is not empty, or None.
 func MaybeEmpty[T any](val T) Option[T] {
 	if IsEmpty(val) {

option_test.go

@@ -32,6 +32,19 @@ func TestFromMayHave(t *testing.T) {
 	is.Equal(Option[int]{hasVal: true, val: 42}, MayHave(cb(42, true)()))
 }
 
+func TestFromMayAt(t *testing.T) {
+	is := assert.New(t)
+
+	slice := []int{10, 20, 30}
+	array := [3]int{40, 50, 60}
+
+	is.Equal(Option[int]{hasVal: true, val: 20}, MayAt(slice, 1))
+	is.Equal(Option[int]{hasVal: true, val: 60}, MayAt(array[:], 2))
+	is.Equal(Option[int]{hasVal: false}, MayAt(slice, -1))
+	is.Equal(Option[int]{hasVal: false}, MayAt(slice, 3))
+	is.Equal(Option[int]{hasVal: false}, MayAt([]int{}, 0))
+}
+
 func TestOptionMaybeCast(t *testing.T) {
 	is := assert.New(t)
 

result_make.go

@@ -37,6 +37,15 @@ func TryLookUp[K comparable, T any](m map[K]T, key K) Result[T] {
 	return Ok(val)
 }
 
+// TryAt attempts to retrieve an element from a slice by index, returning a Result.
+// Arrays can be passed as arr[:].
+func TryAt[T any](x []T, index int) Result[T] {
+	if index < 0 || index >= len(x) {
+		return Err[T](fmt.Errorf("%w: index %d out of bounds", ErrNoSuchElement, index))
+	}
+	return Ok(x[index])
+}
+
 // TryIf constructs a Result with no value from just a boolean flag.
 func TryIf(ok bool) Result[Unit] {
 	if !ok {
@@ -80,6 +89,12 @@ func MustLookUp[K comparable, T any](m map[K]T, key K) T {
 	return TryLookUp(m, key).Yield()
 }
 
+// MustAt retrieves an element from a slice by index, bails out if the index is out of bounds.
+// Arrays can be passed as arr[:].
+func MustAt[T any](x []T, index int) T {
+	return TryAt(x, index).Yield()
+}
+
 // MustTrue bails out if the boolean flag is false.
 func MustTrue(ok bool) {
 	TryIf(ok).Yield()

result_test.go

@@ -42,6 +42,19 @@ func TestResultTryIf(t *testing.T) {
 	is.Equal(Try(3, fmt.Errorf("%w: %T", ErrNoSuchElement, 3)), TryHave(3, false))
 }
 
+func TestResultTryAt(t *testing.T) {
+	is := assert.New(t)
+
+	slice := []int{10, 20, 30}
+	array := [3]int{40, 50, 60}
+
+	is.Equal(Ok(20), TryAt(slice, 1))
+	is.Equal(Ok(60), TryAt(array[:], 2))
+	is.ErrorIs(TryAt(slice, -1).Err(), ErrNoSuchElement)
+	is.ErrorIs(TryAt(slice, 3).Err(), ErrNoSuchElement)
+	is.ErrorIs(TryAt([]int{}, 0).Err(), ErrNoSuchElement)
+}
+
 func TestResultTryCast(t *testing.T) {
 	is := assert.New(t)
 
@@ -95,6 +108,22 @@ func TestResultMustOk(t *testing.T) {
 	is.Equal(42, Ok(42).Yield())
 }
 
+func TestResultMustAt(t *testing.T) {
+	is := assert.New(t)
+
+	slice := []int{10, 20, 30}
+	array := [3]int{40, 50, 60}
+
+	is.Equal(20, MustAt(slice, 1))
+	is.Equal(60, MustAt(array[:], 2))
+	is.Panics(func() {
+		MustAt(slice, -1)
+	})
+	is.Panics(func() {
+		MustAt(slice, 3)
+	})
+}
+
 func TestResultOr(t *testing.T) {
 	is := assert.New(t)