nonempty

func Flatten ¶

func Flatten[A any](mma NonEmptyArray[NonEmptyArray[A]]) NonEmptyArray[A]

Flatten flattens a NonEmptyArray of NonEmptyArrays into a single NonEmptyArray. This operation concatenates all inner arrays into one.

Type Parameters:

• A: The element type

Parameters:

• mma: A NonEmptyArray of NonEmptyArrays

Returns:

• NonEmptyArray[A]: A flattened NonEmptyArray containing all elements

Example:

nested := From(From(1, 2), From(3, 4), From(5))
flat := Flatten(nested)  // NonEmptyArray[int]{1, 2, 3, 4, 5}

func From ¶

func From[A any](first A, data ...A) NonEmptyArray[A]

From constructs a NonEmptyArray from a set of variadic arguments. The first argument is required to ensure the array is non-empty, and additional elements can be provided as variadic arguments.

Type Parameters:

• A: The element type

Parameters:

• first: The first element (required to ensure non-emptiness)
• data: Additional elements (optional)

Returns:

• NonEmptyArray[A]: A NonEmptyArray containing all provided elements

Example:

arr1 := From(1)              // NonEmptyArray[int]{1}
arr2 := From(1, 2, 3)        // NonEmptyArray[int]{1, 2, 3}
arr3 := From("a", "b", "c")  // NonEmptyArray[string]{"a", "b", "c"}

func MonadAp ¶

func MonadAp[B, A any](fab NonEmptyArray[func(A) B], fa NonEmptyArray[A]) NonEmptyArray[B]

MonadAp applies a NonEmptyArray of functions to a NonEmptyArray of values. Each function is applied to each value, producing a cartesian product of results.

Type Parameters:

• B: The output element type
• A: The input element type

Parameters:

• fab: A NonEmptyArray of functions
• fa: A NonEmptyArray of values

Returns:

• NonEmptyArray[B]: The result of applying all functions to all values

Example:

fns := From(N.Mul(2), func(x int) int { return x + 10 })
vals := From(1, 2)
result := MonadAp(fns, vals)  // NonEmptyArray[int]{2, 4, 11, 12}

func MonadChain ¶

func MonadChain[A, B any](fa NonEmptyArray[A], f Kleisli[A, B]) NonEmptyArray[B]

MonadChain applies a function that returns a NonEmptyArray to each element and flattens the results. This is the monadic bind operation (flatMap) that takes the array as the first parameter.

Type Parameters:

• A: The input element type
• B: The output element type

Parameters:

• fa: The input NonEmptyArray
• f: A function that takes an element and returns a NonEmptyArray

Returns:

• NonEmptyArray[B]: The flattened result

Example:

arr := From(1, 2, 3)
result := MonadChain(arr, func(x int) NonEmptyArray[int] {
    return From(x, x*10)
})  // NonEmptyArray[int]{1, 10, 2, 20, 3, 30}

func MonadMap ¶

func MonadMap[A, B any](as NonEmptyArray[A], f func(a A) B) NonEmptyArray[B]

MonadMap applies a function to each element of a NonEmptyArray, returning a new NonEmptyArray with the results. This is the monadic version of Map that takes the array as the first parameter.

Type Parameters:

• A: The input element type
• B: The output element type

Parameters:

• as: The input NonEmptyArray
• f: The function to apply to each element

Returns:

• NonEmptyArray[B]: A new NonEmptyArray with the transformed elements

Example:

arr := From(1, 2, 3)
doubled := MonadMap(arr, N.Mul(2))  // NonEmptyArray[int]{2, 4, 6}

func Of ¶

func Of[A any](first A) NonEmptyArray[A]

Of constructs a single element NonEmptyArray. This is the simplest way to create a NonEmptyArray with exactly one element.

Type Parameters:

• A: The element type

Parameters:

• first: The single element to include in the array

Returns:

• NonEmptyArray[A]: A NonEmptyArray containing only the provided element

Example:

arr := Of(42)           // NonEmptyArray[int]{42}
str := Of("hello")      // NonEmptyArray[string]{"hello"}

func Chain ¶

func Chain[A, B any](f func(A) NonEmptyArray[B]) Operator[A, B]

Chain applies a function that returns a NonEmptyArray to each element and flattens the results. This is the curried version of MonadChain.

Type Parameters:

• A: The input element type
• B: The output element type

Parameters:

• f: A function that takes an element and returns a NonEmptyArray

Returns:

• Operator[A, B]: A function that transforms NonEmptyArray[A] to NonEmptyArray[B]

Example:

duplicate := Chain(func(x int) NonEmptyArray[int] { return From(x, x) })
result := duplicate(From(1, 2, 3))  // NonEmptyArray[int]{1, 1, 2, 2, 3, 3}

func Extend ¶ added in v2.1.7

func Extend[A, B any](f func(NonEmptyArray[A]) B) Operator[A, B]

Extend applies a function to all suffixes of a NonEmptyArray. For each position i, it applies the function to the subarray starting at position i. This is part of the Comonad interface.

Type Parameters:

• A: The input element type
• B: The output element type

Parameters:

• f: A function that takes a NonEmptyArray and returns a value

Returns:

• Operator[A, B]: A function that transforms NonEmptyArray[A] to NonEmptyArray[B]

Example:

arr := From(1, 2, 3, 4)
sumSuffix := Extend(func(xs NonEmptyArray[int]) int {
    sum := 0
    for _, x := range xs {
        sum += x
    }
    return sum
})
result := sumSuffix(arr)  // NonEmptyArray[int]{10, 9, 7, 4}
// [1,2,3,4] -> 10, [2,3,4] -> 9, [3,4] -> 7, [4] -> 4

func Map ¶

func Map[A, B any](f func(a A) B) Operator[A, B]

Map applies a function to each element of a NonEmptyArray, returning a new NonEmptyArray with the results. This is the curried version that returns a function.

Type Parameters:

• A: The input element type
• B: The output element type

Parameters:

• f: The function to apply to each element

Returns:

• Operator[A, B]: A function that transforms NonEmptyArray[A] to NonEmptyArray[B]

Example:

double := Map(N.Mul(2))
result := double(From(1, 2, 3))  // NonEmptyArray[int]{2, 4, 6}

func ToNonEmptyArray ¶

func ToNonEmptyArray[A any](as []A) Option[NonEmptyArray[A]]

ToNonEmptyArray attempts to convert a regular slice into a NonEmptyArray. This function provides a safe way to create a NonEmptyArray from a slice that might be empty, returning an Option type to handle the case where the input slice is empty.

Type Parameters:

• A: The element type of the array

Parameters:

• as: A regular slice that may or may not be empty

Returns:

• Option[NonEmptyArray[A]]: Some(NonEmptyArray) if the input slice is non-empty, None if empty

Behavior:

• If the input slice is empty, returns None
• If the input slice has at least one element, wraps it in Some and returns it as a NonEmptyArray
• The conversion is a type cast, so no data is copied

Example:

// Convert non-empty slice
numbers := []int{1, 2, 3}
result := ToNonEmptyArray(numbers)  // Some(NonEmptyArray[1, 2, 3])

// Convert empty slice
empty := []int{}
result := ToNonEmptyArray(empty)  // None

// Use with Option methods
numbers := []int{1, 2, 3}
result := ToNonEmptyArray(numbers)
if O.IsSome(result) {
    nea := O.GetOrElse(F.Constant(From(0)))(result)
    head := Head(nea)  // 1
}

Use cases:

• Safely converting user input or external data to NonEmptyArray
• Validating that a collection has at least one element before processing
• Converting results from functions that return regular slices
• Ensuring type safety when working with collections that must not be empty

Example with validation:

func processItems(items []string) Option[string] {
    return F.Pipe2(
        items,
        ToNonEmptyArray[string],
        O.Map(func(nea NonEmptyArray[string]) string {
            return Head(nea)  // Safe to get head since we know it's non-empty
        }),
    )
}

Example with error handling:

items := []int{1, 2, 3}
result := ToNonEmptyArray(items)
switch {
case O.IsSome(result):
    nea := O.GetOrElse(F.Constant(From(0)))(result)
    fmt.Println("First item:", Head(nea))
case O.IsNone(result):
    fmt.Println("Array is empty")
}

Example with chaining:

// Process only if non-empty
result := F.Pipe3(
    []int{1, 2, 3},
    ToNonEmptyArray[int],
    O.Map(Map(N.Mul(2))),
    O.Map(Head[int]),
)  // Some(2)

Note: This function is particularly useful when working with APIs or functions that return regular slices but you need the type-level guarantee that the collection is non-empty for subsequent operations.