Lo

https://pkg.go.dev/github.com/samber/lo
Admin
Lo is a Go library that provides a comprehensive collection of utility functions for common data...
Tokens:106,813
Snippets:677
Trust Score:10
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install Development Dependencies (Make)

Source: https://pkg.go.dev/github.com/samber/lo/index

This command installs necessary development dependencies for the project using the `make tools` command.

```bash
# Install some dev dependencies
make tools
```

--------------------------------

### Generate Sequence from Start Value (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Generates a sequence of numeric types starting from a given value and continuing for a specified number of elements.

```Go
func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) iter.Seq[T]
```

--------------------------------

### Import and Use samber/lo Helpers in Go

Source: https://pkg.go.dev/github.com/samber/lo/index

Demonstrates how to import and use the `samber/lo` package and its sub-packages for various utilities. It shows common import aliases for parallel processing, mutable operations, and iterator helpers. The example illustrates using the `Uniq` function to get unique elements from a string slice.

```go
import (
    "github.com/samber/lo"
    lop "github.com/samber/lo/parallel"
    lom "github.com/samber/lo/mutable"
    loi "github.com/samber/lo/it"
)

// Example usage:
names := lo.Uniq([]string{"Samuel", "John", "Samuel"})
// names will be []string{"Samuel", "John"}

```

--------------------------------

### Install samber/lo Go Package

Source: https://pkg.go.dev/github.com/samber/lo/index

Installs the `samber/lo` package, version v1, using the Go module system. This command fetches the specified version of the library and adds it to your project's dependencies. The library follows SemVer strictly for its exported APIs.

```bash
go get github.com/samber/lo@v1

```

--------------------------------

### Generate Sequence with Steps (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Generates a sequence of numeric types starting from a given value, ending before a specified value, with a defined step.

```Go
func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step T) iter.Seq[T]
```

--------------------------------

### Time Utility Functions (Go)

Source: https://pkg.go.dev/github.com/samber/lo/internal/xtime

Provides utility functions for working with time, such as getting the current time, calculating time differences, and simulating sleep. These functions operate through the Clock interface, allowing them to work with both real and mocked time.

```go
func Now() time.Time
```

```go
func SetClock(c Clock)
```

```go
func Since(t time.Time) time.Duration
```

```go
func Sleep(d time.Duration)
```

```go
func Until(t time.Time) time.Duration
```

--------------------------------

### Check for Sequence Prefix (HasPrefix) in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

Returns true if the sequence starts with the specified prefix. The function iterates at most the length of the prefix, making it efficient for prefix checks. It accepts variadic arguments for the prefix elements.

```go
func HasPrefix[T comparable](collection iter.Seq[T], prefix ...T) bool {
    // Implementation details omitted for brevity
    return false
}
```

--------------------------------

### Zip7: Create a sequence of grouped elements from 7 sequences in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

Zip7 creates a sequence of grouped elements, where each element is a tuple containing corresponding elements from the input sequences. It supports generic types for up to 7 input sequences. If sequences have different lengths, the tuple attributes are padded with zero values. Playable example available.

```Go
func Zip7[A, B, C, D, E, F, G any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E], f iter.Seq[F], g iter.Seq[G]) iter.Seq[lo.Tuple7[A, B, C, D, E, F, G]] {
  // Implementation details omitted for brevity
  return nil
}
```

--------------------------------

### ZipBy5: Transform elements from 5 sequences in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

ZipBy5 creates a sequence of transformed elements by applying a provided transform function to corresponding elements from five input sequences. It supports generic types for input elements and the output. If sequences have different lengths, the transformation stops at the shortest sequence's end. Playable example available.

```Go
func ZipBy5[A, B, C, D, E, Out any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E], transform func(a A, b B, c C, d D, e E) Out) iter.Seq[Out] {
  // Implementation details omitted for brevity
  return nil
}
```

--------------------------------

### Run Project Tests (Make)

Source: https://pkg.go.dev/github.com/samber/lo/index

These commands execute the project's tests. `make test` runs the tests once, while `make watch-test` continuously runs tests as files are changed.

```bash
# Run tests
make test
# or
make watch-test
```

--------------------------------

### ZipBy3: Transform elements from 3 sequences in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

ZipBy3 creates a sequence of transformed elements by applying a provided transform function to corresponding elements from three input sequences. It supports generic types for input elements and the output. If sequences have different lengths, the transformation stops at the shortest sequence's end. Playable example available.

```Go
func ZipBy3[A, B, C, Out any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], transform func(a A, b B, c C) Out) iter.Seq[Out] {
  // Implementation details omitted for brevity
  return nil
}
```

--------------------------------

### Zip8: Create a sequence of grouped elements from 8 sequences in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

Zip8 creates a sequence of grouped elements, where each element is a tuple containing corresponding elements from the input sequences. It supports generic types for up to 8 input sequences. If sequences have different lengths, the tuple attributes are padded with zero values. Playable example available.

```Go
func Zip8[A, B, C, D, E, F, G, H any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E], f iter.Seq[F], g iter.Seq[G], h iter.Seq[H]) iter.Seq[lo.Tuple8[A, B, C, D, E, F, G, H]] {
  // Implementation details omitted for brevity
  return nil
}
```

--------------------------------

### ZipBy2: Transform elements from 2 sequences in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

ZipBy2 creates a sequence of transformed elements by applying a provided transform function to corresponding elements from two input sequences. It supports generic types for input elements and the output. If sequences have different lengths, the transformation stops at the shortest sequence's end. Playable example available.

```Go
func ZipBy2[A, B, Out any](a iter.Seq[A], b iter.Seq[B], transform func(a A, b B) Out) iter.Seq[Out] {
  // Implementation details omitted for brevity
  return nil
}
```

--------------------------------

### Extract Substring (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns a portion of a string based on start index and length. Handles negative start indices and maximum length.

```go
package main

import (
	"fmt"
	"math"
	"github.com/samber/lo"
)

func main() {
	sub1 := lo.Substring("hello", 2, 3)
	fmt.Println(sub1) // Output: "llo"

	sub2 := lo.Substring("hello", -4, 3)
	fmt.Println(sub2) // Output: "ell"

	sub3 := lo.Substring("hello", -2, math.MaxUint)
	fmt.Println(sub3) // Output: "lo"
}
```

--------------------------------

### Clock Interface Definition (Go)

Source: https://pkg.go.dev/github.com/samber/lo/internal/xtime

Defines the Clock interface, which abstracts time-related operations. Implementations of this interface can be used to mock or control time in tests. It includes methods for getting the current time, calculating time differences, and pausing execution.

```go
type Clock interface {
	Now() time.Time
	Since(t time.Time) time.Duration
	Until(t time.Time) time.Duration
	Sleep(d time.Duration)
}
```

--------------------------------

### Tuple Utilities

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Utilities for creating and unpacking tuple-like structures.

```APIDOC
## Tuple Utilities

### Description
Provides types and methods for creating and working with fixed-size collections of heterogeneous types, similar to tuples in other languages.

### Tuple Types

#### `type Tuple2[A any, B any]`

**Description**: Represents a tuple of two elements.

**Methods**:

##### `func (t Tuple2[A, B]) Unpack() (A, B)`

**Description**: Unpacks the elements of the tuple into separate variables.

**Returns**:
- `A` - The first element.
- `B` - The second element.

#### `type Tuple3[A any, B any, C any]`

**Description**: Represents a tuple of three elements.

**Methods**:

##### `func (t Tuple3[A, B, C]) Unpack() (A, B, C)`

**Description**: Unpacks the elements of the tuple into separate variables.

**Returns**:
- `A` - The first element.
- `B` - The second element.
- `C` - The third element.

#### `type Tuple4[A any, B any, C any, D any]`

**Description**: Represents a tuple of four elements.

**Methods**:

##### `func (t Tuple4[A, B, C, D]) Unpack() (A, B, C, D)`

**Description**: Unpacks the elements of the tuple into separate variables.

**Returns**:
- `A` - The first element.
- `B` - The second element.
- `C` - The third element.
- `D` - The fourth element.

#### `type Tuple5[A any, B any, C any, D any, E any]`

**Description**: Represents a tuple of five elements.

**Methods**:

##### `func (t Tuple5[A, B, C, D, E]) Unpack() (A, B, C, D, E)`

**Description**: Unpacks the elements of the
```

--------------------------------

### Extract a slice safely with lo.Slice

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns a copy of a slice from a start index up to, but not including, an end index. This function is similar to standard Go slicing `slice[start:end]` but avoids panics by handling out-of-bounds indices. It gracefully manages cases where the end index exceeds the slice length or when the start index is greater than or equal to the end index.

```go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

func main() {
	in := []int{0, 1, 2, 3, 4}

	slice := lo.Slice(in, 0, 5)
	fmt.Println(slice) // Output: [0 1 2 3 4]

	slice = lo.Slice(in, 2, 3)
	fmt.Println(slice) // Output: [2]

	slice = lo.Slice(in, 2, 6)
	fmt.Println(slice) // Output: [2 3 4]

	slice = lo.Slice(in, 4, 3)
	fmt.Println(slice) // Output: []
}
```

--------------------------------

### Generate Sequence of Integers (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Generates a sequence of integers starting from 0 up to (but not including) the specified element number.

```Go
func Range(elementNum int) iter.Seq[int]
```

--------------------------------

### Zip9: Create a sequence of grouped elements from 9 sequences in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

Zip9 creates a sequence of grouped elements, where each element is a tuple containing corresponding elements from the input sequences. It supports generic types for up to 9 input sequences. If sequences have different lengths, the tuple attributes are padded with zero values. Playable example available.

```Go
func Zip9[A, B, C, D, E, F, G, H, I any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E], f iter.Seq[F], g iter.Seq[G], h iter.Seq[H], i iter.Seq[I]) iter.Seq[lo.Tuple9[A, B, C, D, E, F, G, H, I]] {
  // Implementation details omitted for brevity
  return nil
}
```

--------------------------------

### Function Utilities

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Utilities for functional programming concepts like partial application and debouncing.

```APIDOC
## Function Utilities

### Description
Provides utilities for enhancing and manipulating functions, including partial application and debouncing.

### Functions

#### `func Partial1[T1 any, T2 any, R any](f func(T1, T2) R, arg1 T1) func(T2) R`

**Description**: Creates a new function by pre-filling the first argument of a two-argument function.

**Parameters**:
- `f` (func(T1, T2) R) - The original function.
- `arg1` (T1) - The first argument to pre-fill.

**Returns**:
- `func(T2) R` - The new function with the first argument applied.

#### `func Partial2[T1 any, T2 any, T3 any, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R`

**Description**: Creates a new function by pre-filling the first argument of a three-argument function.

**Parameters**:
- `f` (func(T1, T2, T3) R) - The original function.
- `arg1` (T1) - The first argument to pre-fill.

**Returns**:
- `func(T2, T3) R` - The new function with the first argument applied.

#### `func Partial3[T1 any, T2 any, T3 any, T4 any, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R`

**Description**: Creates a new function by pre-filling the first argument of a four-argument function.

**Parameters**:
- `f` (func(T1, T2, T3, T4) R) - The original function.
- `arg1` (T1) - The first argument to pre-fill.

**Returns**:
- `func(T2, T3, T4) R` - The new function with the first argument applied.

#### `func Partial4[T1 any, T2 any, T3 any, T4 any, T5 any, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R`

**Description**: Creates a new function by pre-filling the first argument of a five-argument function.

**Parameters**:
- `f` (func(T1, T2, T3, T4, T5) R) - The original function.
- `arg1` (T1) - The first argument to pre-fill.

**Returns**:
- `func(T2, T3, T4, T5) R` - The new function with the first argument applied.

#### `func Partial5[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R`

**Description**: Creates a new function by pre-filling the first argument of a six-argument function.

**Parameters**:
- `f` (func(T1, T2, T3, T4, T5, T6) R) - The original function.
- `arg1` (T1) - The first argument to pre-fill.

**Returns**:
- `func(T2, T3, T4, T5, T6) R` - The new function with the first argument applied.

#### `func NewDebounceBy(duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))`

**Description**: Creates debounced functions for executing callbacks after a specified delay, with support for multiple callbacks and key-based debouncing.

**Parameters**:
- `duration` (time.Duration) - The delay before executing the callback.
- `f` (...func(key T, count int)) - Variadic list of callback functions to execute.

**Returns**:
- `func(key T)` - The debounced function to call.
- `func(key T)` - A function to cancel any pending debounced calls for a given key.

#### `func EmptyableToPtr[T any](x T) *T`

**Description**: Converts a value to a pointer, handling empty values by returning nil.

**Parameters**:
- `x` (T) - The value to convert.

**Returns**:
- `*T` - A pointer to the value, or nil if the value is considered empty.
```

--------------------------------

### Get Values from Maps (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Extracts all values from one or more input maps and returns them as a sequence. Values can be of any type.

```go
func Values[K comparable, V any](in ...map[K]V) iter.Seq[V]
```

--------------------------------

### Get Sequence Length in Go

Source: https://pkg.go.dev/github.com/samber/lo/it_tab=versions

The `Length` function returns the number of elements in a sequence.

```Go
func Length[T any](collection iter.Seq[T]) int
```

--------------------------------

### RealClock Implementation (Go)

Source: https://pkg.go.dev/github.com/samber/lo/internal/xtime

The RealClock type implements the Clock interface using the actual system time. This provides a way to use the standard time package's behavior through the Clock interface. It's useful when you need to interact with the real time but want to maintain compatibility with the xtime's interface.

```go
type RealClock struct {
	// contains filtered or unexported fields
}
```

```go
func NewRealClock() *RealClock
```

```go
func (c *RealClock) Now() time.Time
```

```go
func (c *RealClock) Since(t time.Time) time.Duration
```

```go
func (c *RealClock) Sleep(d time.Duration)
```

```go
func (c *RealClock) Until(t time.Time) time.Duration
```

--------------------------------

### Create partially applied functions with multiple args in Go (Partial2-5)

Source: https://pkg.go.dev/github.com/samber/lo/index

Functions like Partial2, Partial3, Partial4, and Partial5 allow pre-filling the first two, three, four, or five arguments of a function, respectively. This extends the utility of partial application to functions with more parameters.

```go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

func main() {
	add := func(x, y, z int) int { return x + y + z }
	f := lo.Partial2(add, 42)

	fmt.Println(f(10, 5))
	// 57

	fmt.Println(f(42, -4))
	// 80
}

```

--------------------------------

### Get Unique Values from Maps (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Extracts all unique values from one or more input maps and returns them as a sequence. Values must be comparable.

```go
func UniqValues[K, V comparable](in ...map[K]V) iter.Seq[V]
```

--------------------------------

### Get Unique Keys from Maps (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Extracts all unique keys from one or more input maps and returns them as a sequence. Keys must be comparable.

```go
func UniqKeys[K comparable, V any](in ...map[K]V) iter.Seq[K]
```

--------------------------------

### Apply Partial Function Arguments in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Enables creating new functions by pre-filling some arguments of an existing function. `Partial1` through `Partial5` allow fixing the first argument of functions with varying numbers of parameters, returning a new function that accepts the remaining arguments. This is useful for creating specialized versions of generic functions.

```go
func Partial1(f func(T1, T2) R, arg1 T1) func(T2) R
func Partial2(f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R
func Partial3(f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R
func Partial4(f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R
func Partial5(f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R
```

--------------------------------

### Check for Slice Prefixes and Suffixes in Go

Source: https://pkg.go.dev/github.com/samber/lo/index

Verifies if a slice starts with or ends with a given prefix or suffix sequence.

```go
func HasPrefix[T comparable](collection, prefix []T) bool
func HasSuffix[T comparable](collection, suffix []T) bool
```

--------------------------------

### Concurrency Utilities in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Functions designed to simplify concurrent programming. This includes asynchronous function execution returning channels, and utilities for managing multiple lockers.

```Go
func Async[T any](f func() T) chan T
func Async0(f func())
func Async1[A any](f func() A) chan A
func Async2[A any, B any](f func() (A, B)) chan Tuple2[A, B]
func Async3[A any, B any, C any](f func() (A, B, C)) chan Tuple3[A, B, C]
func Async4[A any, B any, C any, D any](f func() (A, B, C, D)) chan Tuple4[A, B, C, D]
func Async5[A any, B any, C any, D any, E any](f func() (A, B, C, D, E)) chan Tuple5[A, B, C, D, E]
func Async6[A any, B any, C any, D any, E any, F any](f func() (A, B, C, D, E, F)) chan Tuple6[A, B, C, D, E, F]
func Synchronize(opt ...sync.Locker) *synchronize
```

--------------------------------

### Trim Prefix from Collection (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Removes a specified prefix from the beginning of a collection. The prefix must match exactly from the start of the collection. Works with comparable types.

```go
func TrimPrefix[T comparable, I ~func(func(T) bool)](collection I, prefix []T) I
```

--------------------------------

### Partial Application in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Implements partial application for functions. The `Partial` function takes a function and one of its arguments, returning a new function that expects the remaining arguments.

```Go
func Partial[T1 any, T2 any, R any](f func(T1, T2) R, arg1 T1) func(T2) R
```

--------------------------------

### Create Set from Sequence with Keyify in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

Keyify generates a map where keys are the unique elements from a sequence, and values are empty structs. It iterates through the entire sequence to collect unique items, effectively creating a set. This is useful for fast membership checking.

```go
import (
	"github.com/samber/lo/pkg/iter"
)

func Keyify[T comparable](collection iter.Seq[T]) map[T]struct{} {
	// Implementation details...
}
```

--------------------------------

### Extract Subset from Collection (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Returns a new collection containing a specified number of elements starting from a given offset. The original collection remains unchanged.

```Go
func Subset[T any, I ~func(func(T) bool)](collection I, offset, length int) I
```

--------------------------------

### Get All Values from Maps in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

Values creates a sequence of all values present in the input maps. This function is useful for extracting all data points from a collection of maps.

```go
import "github.com/samber/lo/v2/iter"

func Values[K comparable, V any](in ...map[K]V) iter.Seq[V]
```

--------------------------------

### Partition Collection by Key (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Partitions a collection into sub-slices based on a transformation function that generates a comparable key for each item. Returns a slice of slices, where each inner slice contains elements with the same key.

```Go
func PartitionBy[T any, K comparable](collection iter.Seq[T], transform func(item T) K) [][]T
```

--------------------------------

### Sample

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns a random item from a collection. Returns the zero value if the collection is empty.

```APIDOC
## Sample

### Description
Returns a random item from a collection. If the collection is empty, it returns the zero value for the element type.

### Method
`lo.Sample[T any](collection []T) T`

### Parameters
* `collection` ([]T) - The collection to sample from.

### Response
* `T` - A random element from the collection, or the zero value if the collection is empty.

### Request Example
```go
// Example 1: Non-empty collection
// Returns a random string from the slice
sample := lo.Sample([]string{"a", "b", "c"})
// Example Output: "a", "b", or "c"

// Example 2: Empty collection
sample := lo.Sample([]string{})
// sample: ""
```
```

--------------------------------

### Extract Slice from Collection (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Returns a new collection containing elements from a specified range (start to end) of the original collection. The original collection remains unchanged.

```Go
func Slice[T any, I ~func(func(T) bool)](collection I, start, end int) I
```

--------------------------------

### Get Nth Element from Collection (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Retrieves the element at a specific index (nth) from a collection. Returns an error if the index is out of bounds. Supports integer types for the index.

```Go
func Nth[T any, N constraints.Integer](collection iter.Seq[T], nth N) (T, error)
```

--------------------------------

### Samples

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns N unique random items from a collection.

```APIDOC
## Samples

### Description
Returns N unique random items from a collection. The order of the returned items is random.

### Method
`lo.Samples[T any](collection []T, n int) []T`

### Parameters
* `collection` ([]T) - The collection to sample from.
* `n` (int) - The number of unique random items to return.

### Response
* `[]T` - A slice containing N unique random items from the collection, in random order.

### Request Example
```go
// Example: Get 3 unique random samples
samples := lo.Samples([]string{"a", "b", "c"}, 3)
// Example Output: []string{"a", "b", "c"} in random order
```
```

--------------------------------

### Create Map from Sequence with Index in Go (AssociateI)

Source: https://pkg.go.dev/github.com/samber/lo/it

The AssociateI function is similar to Associate but also provides the index of the element to the transform function. This allows for transformations that depend on the element's position within the sequence. Like Associate, it handles duplicate keys by keeping the last entry and does not guarantee key order.

```go
func AssociateI[T any, K comparable, V any](collection iter.Seq[T], transform func(item T, index int) (K, V)) map[K]V {
    // Implementation details omitted for brevity
    return nil
}
```

--------------------------------

### Convert String to camelCase (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index

Converts a string to camelCase, where the first letter is lowercase and subsequent words start with an uppercase letter, with no separators.

```go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

func main() {
	str := lo.CamelCase("hello_world")
	fmt.Println(str) // Output: helloWorld
}
```

--------------------------------

### CutPrefix

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns a collection without the provided leading prefix and reports whether the prefix was found.

```APIDOC
## CutPrefix

### Description
CutPrefix returns collection without the provided leading prefix []T and reports whether it found the prefix. If s doesn't start with prefix, CutPrefix returns collection, false. If prefix is the empty []T, CutPrefix returns collection, true.

### Method
N/A (Function Signature)

### Endpoint
N/A (Function Signature)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
// Example usage:
// func CutPrefix[T comparable, Slice ~[]T](collection, separator Slice) (after Slice, found bool)
// Example Output:
// After: [d e f g], Found: true
// After: [a b c d e f g], Found: false
// After: [a b c d e f g], Found: true
```

### Response
#### Success Response (200)
- **after** (Slice) - The collection after removing the prefix.
- **found** (bool) - True if the prefix was found and removed, false otherwise.

#### Response Example
```json
// Example response structure:
// {"after": ["d", "e", "f", "g"], "found": true}
```
```

--------------------------------

### Get Nth Element or Fallback (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Retrieves the element at a specific index (nth) from a collection, returning a fallback value if the index is out of bounds. Supports integer types for the index.

```Go
func NthOr[T any, N constraints.Integer](collection iter.Seq[T], nth N, fallback T) T
```

--------------------------------

### Buffer Channel with Context and Size Limit (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Reads elements from a channel into a buffer up to a specified size, respecting a context for cancellation. Returns the buffered elements, their count, read time, and success status.

```go
func BufferWithContext[T any](ctx context.Context, ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
```

--------------------------------

### Empty - Get Zero Value - Go

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns the zero value for a given type. This is a generic way to obtain the default value for any Go type.

```go
lo.Empty[int]()
// 0
lo.Empty[string]()
// ""
lo.Empty[bool]()
// false
```

--------------------------------

### Nil - Get Nil Pointer - Go

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns a nil pointer of a specified type. This function is helpful for creating zero-value pointers for generic types.

```go
ptr := lo.Nil[float64]()
// nil
```

--------------------------------

### String and Numeric Utilities in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Utility functions for string and numeric operations. Includes functions for chunking strings, calculating rune length, and clamping numeric values within a specified range.

```Go
func ChunkString[T any](str T, size int) []T
func RuneLength(str string) int
func Clamp[T constraints.Ordered](value T, min T, max T) T
func SumBy[T any, R number.Number](collection []T, iteratee func(T) R) R
func RepeatBy[T any](count int, predicate func(int) T) []T
func Substring[T string](str T, offset int, length uint) T
```

--------------------------------

### Pointer and Value Handling in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Utility functions for handling pointers and default values. `FromPtrOr` provides a value from a pointer or a fallback, while `FromPtr` dereferences a pointer. `IsEmpty` and `IsNotEmpty` check for emptiness of various types.

```Go
func FromPtrOr[T any](x *T, fallback T) T
func FromPtr[T any](x *T) T
func IsEmpty[T any](v T) bool
func IsNotEmpty[T any](v T) bool
```

--------------------------------

### Get Nth Element or Empty (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Retrieves the element at a specific index (nth) from a collection, returning the zero value of the type if the index is out of bounds. Supports integer types for the index.

```Go
func NthOrEmpty[T any, N constraints.Integer](collection iter.Seq[T], nth N) T
```

--------------------------------

### Async6

Source: https://pkg.go.dev/github.com/samber/lo/index

Async6 is similar to Async but returns 6 results as a tuple within a channel.

```APIDOC
## Async6

### Description
Async6 has the same behavior as Async, but returns the 6 results as a tuple inside the channel.

### Method
N/A (Function Signature)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response
- `<-chan Tuple6[A, B, C, D, E, F]` - A channel returning a tuple of 6 elements.

#### Response Example
N/A
```

--------------------------------

### Get Current Time (Go)

Source: https://pkg.go.dev/github.com/samber/lo/internal/xtime_tab=versions

Retrieves the current time using the system's clock. This function is part of the xtime package and does not require any external dependencies.

```Go
package main

import (
	"fmt"
	"github.com/samber/lo/xtime"
)

func main() {
	now := xtime.Now()
	fmt.Println(now)
}
```

--------------------------------

### Get First or Last Element in Go Slices

Source: https://pkg.go.dev/github.com/samber/lo/index

Retrieves the first or last element of a slice. Includes functions to return a default value if the slice is empty.

```go
func First[T any](collection []T) (T, bool)
func FirstOrEmpty[T any](collection []T) T
func Last[T any](collection []T) (T, bool)
func LastOrEmpty[T any](collection []T) T
```

--------------------------------

### Zip Five Sequences Together (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Combines five sequences into a single sequence of 5-element tuples. The resulting sequence's length is determined by the shortest input sequence.

```go
func Zip5[A, B, C, D, E any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E]) iter.Seq[lo.Tuple5[A, B, C, D, E]]
```

--------------------------------

### Get Rune Length of String (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns the number of Unicode code points (runes) in a string. This is an alias for `utf8.RuneCountInString` and correctly handles multi-byte characters.

```go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

func main() {
	runeLen := lo.RuneLength("hellô")
	fmt.Println(runeLen) // Output: 5

	byteLen := len("hellô")
	fmt.Println(byteLen) // Output: 6
}
```

--------------------------------

### Pointer Utilities

Source: https://pkg.go.dev/github.com/samber/lo/index

Functions for working with pointers.

```APIDOC
## Pointer Utilities

### ToPtr

#### Description
Returns a pointer to the given value.

### Method
`func ToPtr[T any](x T) *T`
```

--------------------------------

### Get First Element of Sequence (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Returns the first element of a sequence and a boolean indicating its availability. It iterates at most once through the sequence. This is useful for safely accessing the initial element of a potentially empty sequence.

```go
func First[T any](collection iter.Seq[T]) (T, bool)
```

--------------------------------

### Get Last Element or Zero Value - lo.LastOrEmpty

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns the last element of a collection or the zero value of its type if the collection is empty. This is the counterpart to lo.FirstOrEmpty for the last element.

```go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

func main() {
	last := lo.LastOrEmpty([]int{1, 2, 3})
	fmt.Println(last)

	last = lo.LastOrEmpty([]int{})
	fmt.Println(last)
}
```

--------------------------------

### Group and Partition Slices in Go (lo library)

Source: https://pkg.go.dev/github.com/samber/lo/parallel_tab=versions

Illustrates the `GroupBy` and `PartitionBy` functions from the 'lo' library for organizing elements within a slice based on a provided key or condition. `GroupBy` creates a map where keys are derived from elements, and `PartitionBy` splits the slice into sub-slices based on a key.

```Go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

type Person struct {
	Name string
	City string
}

func main() {
	people := []Person{
		{"Alice", "New York"},
		{"Bob", "London"},
		{"Charlie", "New York"},
		{"David", "London"},
	}

	// Using GroupBy to group people by city
	peopleByCity := lo.GroupBy(people, func(p Person) string {
		return p.City
	})

	fmt.Println("People grouped by city:", peopleByCity)

	// Using PartitionBy to partition numbers into even and odd
	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	partitionedNumbers := lo.PartitionBy(numbers, func(n int) bool {
		return n%2 == 0 // true for even, false for odd
	})

	fmt.Println("Partitioned numbers (even, odd):", partitionedNumbers)
}
```

--------------------------------

### String Case Conversion (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index

Converts a string to PascalCase.

```Go
func PascalCase(str string) string
```

--------------------------------

### Drop Elements from Sequence Start in Go

Source: https://pkg.go.dev/github.com/samber/lo/it

The Drop function removes a specified number of elements (n) from the beginning of a sequence. It returns a new sequence with the elements dropped. This function is generic and works with any sequence type.

```go
func Drop[T any, I ~func(func(T) bool)](collection I, n int) I
```

--------------------------------

### Zip Seven Sequences Together (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Combines seven sequences into a single sequence of 7-element tuples. The resulting sequence's length is determined by the shortest input sequence.

```go
func Zip7[A, B, C, D, E, F, G any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E], ...) iter.Seq[lo.Tuple7[A, B, C, D, E, F, G]]
```

--------------------------------

### Get Nth Element from Collection (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index

Retrieves the element at a specific index (nth) from a slice. Provides variants to return a fallback value or an empty value if the index is out of bounds.

```Go
func Nth[T any, N constraints.Integer](collection []T, nth N) (T, error)
func NthOr[T any, N constraints.Integer](collection []T, nth N, fallback T) T
func NthOrEmpty[T any, N constraints.Integer](collection []T, nth N) T
```

--------------------------------

### Fan-In and Fan-Out Channels in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Provides utilities for managing concurrent operations using channels. `FanIn` merges multiple input channels into a single output channel, while `FanOut` distributes values from a single upstream channel to multiple downstream channels. These are essential for building concurrent pipelines.

```go
func FanIn(channelBufferCap int, upstreams ...<-chan T) <-chan T
func FanOut(count int, channelsBufferCap int, upstream <-chan T) []<-chan T
```

--------------------------------

### Zip Eight Sequences Together (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Combines eight sequences into a single sequence of 8-element tuples. The resulting sequence's length is determined by the shortest input sequence.

```go
func Zip8[A, B, C, D, E, F, G, H any](a iter.Seq[A], b iter.Seq[B], c iter.Seq[C], d iter.Seq[D], e iter.Seq[E], ...) iter.Seq[lo.Tuple8[A, B, C, D, E, F, G, H]]
```

--------------------------------

### Get Last Element or Fallback Value - lo.LastOr

Source: https://pkg.go.dev/github.com/samber/lo/index

Returns the last element of a collection or a specified fallback value if the collection is empty. This offers a customizable default for the last element.

```go
package main

import (
	"fmt"
	"github.com/samber/lo"
)

func main() {
	last := lo.LastOr([]int{1, 2, 3}, 245)
	fmt.Println(last)

	last = lo.LastOr([]int{}, 31)
	fmt.Println(last)
}
```

--------------------------------

### Tuple and Unpacking Functions in Go

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Provides generic tuple types and functions to create and unpack them. Supports tuples from 2 to 9 elements, facilitating the return and handling of multiple values from functions.

```Go
type Tuple2[A any, B any]
func T2[A any, B any](a A, b B) Tuple2[A, B]
func Unpack2[A any, B any](tuple Tuple2[A, B]) (A, B)
type Tuple3[A any, B any, C any]
func T3[A any, B any, C any](a A, b B, c C) Tuple3[A, B, C]
func Unpack3[A any, B any, C any](tuple Tuple3[A, B, C]) (A, B, C)
type Tuple4[A any, B any, C any, D any]
func T4[A any, B any, C any, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]
func Unpack4[A any, B any, C any, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D)
type Tuple5[A any, B any, C any, D any, E any]
func T5[A any, B any, C any, D any, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]
func Unpack5[A any, B any, C any, D any, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E)
type Tuple6[A any, B any, C any, D any, E any, F any]
func T6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]
func Unpack6[A any, B any, C any, D any, E any, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)
type Tuple7[A any, B any, C any, D any, E any, F any, G any]
func T7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]
func Unpack7[A any, B any, C any, D any, E any, F any, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)
type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any]
func T8[A any, B any, C any, D any, E any, F any, G any, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]
func Unpack8[A any, B any, C any, D any, E any, F any, G any, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)
type Tuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any]
func T9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I]
func Unpack9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)
```

--------------------------------

### Find or Default in Go Collections

Source: https://pkg.go.dev/github.com/samber/lo/index

Retrieves an element from a collection, returning a fallback value if no matching element is found. Also includes functions to get the first or last element with fallbacks.

```go
func FindOrElse[T any](collection []T, fallback T, predicate func(item T) bool) T
func FirstOr[T any](collection []T, fallback T) T
func LastOr[T any](collection []T, fallback T) T
```

--------------------------------

### Dispatching Strategy

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Utilities for defining and using dispatching strategies, particularly for message distribution.

```APIDOC
## DispatchingStrategy

### Description
A function type for defining message dispatching strategies.

### Method
N/A (Type Definition)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

#### Response Example
N/A

## DispatchingStrategyWeightedRandom

### Description
Creates a weighted random dispatching strategy.

### Method
N/A (Function)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A


```

--------------------------------

### Get Map Value or Default (Go)

Source: https://pkg.go.dev/github.com/samber/lo/index

Retrieves the value associated with a given key from a map. If the key is not found, it returns a specified fallback (default) value instead of causing an error.

```Go
value := lo.ValueOr(map[string]int{"foo": 1, "bar": 2}, "foo", 42)
// 1

value := lo.ValueOr(map[string]int{"foo": 1, "bar": 2}, "baz", 42)
// 42
```

--------------------------------

### Get First Element or Zero Value (Go)

Source: https://pkg.go.dev/github.com/samber/lo/it

Returns the first element of a sequence, or the zero value of the element type if the sequence is empty. The function iterates at most once. This is useful when a default zero value is acceptable for an empty sequence.

```go
func FirstOrEmpty[T any](collection iter.Seq[T]) T
```

--------------------------------

### Map Creation from Slices with Transformations

Source: https://pkg.go.dev/github.com/samber/lo/index_tab=versions

Functions for converting slices into maps, allowing for custom key-value transformations. `AssociateI` and `SliceToMapI` create maps directly, while `FilterSliceToMapI` allows filtering during the map creation process.

```go
func AssociateI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V
func FilterSliceToMapI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V, bool)) map[K]V
func SliceToMapI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V
```
Tokens:
Raw