samber/lo

https://lo.samber.dev/docs/
Admin
A Lodash-style utility library for Go that provides hundreds of functional programming helpers for...
Tokens:173,013
Snippets:989
Trust Score:4.8
Update:7 months ago
Show doc for...
Tokens:
Raw
### Variadic Function Example (Go)

Source: https://lo.samber.dev/docs/contributing

Demonstrates how variadic functions in Go can accept multiple arguments of the same type, providing flexibility. This example uses `lo.Keys` which can accept multiple maps.

```Go
package main

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

func main() {
	map1 := map[string]int{"a": 1, "b": 2}
	map2 := map[string]int{"c": 3, "d": 4}
	map3 := map[string]int{"e": 5}

	keys := lo.Keys(map1, map2, map3)
	fmt.Println(keys) // Output: [a b c d e]
}
```

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

### Create Integer Slice from Start Value (Go)

Source: https://lo.samber.dev/docs/core/math

Creates a slice of integers starting at a specified value with a given length. A negative length results in a descending sequence.

```go
lo.RangeFrom(1, 5)
// []int{1, 2, 3, 4, 5}
```

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

### Install samber/lo Utility Library

Source: https://lo.samber.dev/docs/about

Installs the latest version of the samber/lo library using the Go toolchain. This library is v1 and strictly follows SemVer, ensuring no breaking changes to exported APIs before v2.0.0. It has no dependencies outside the Go standard library.

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

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

### Create Integer Slice with Range (Go)

Source: https://lo.samber.dev/docs/core/math

Generates a slice of integers starting from 0. The length determines the number of elements. A negative length produces a descending sequence.

```go
lo.Range(4)
// []int{0, 1, 2, 3}

lo.Range(-4)
// []int{0, -1, -2, -3}
```

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

### Slice Type Parameter Example (Go)

Source: https://lo.samber.dev/docs/contributing

Illustrates the use of `~[]T` constraints in Go for generic functions, allowing them to accept any slice type, including named slice types. This enhances flexibility for real-world usage.

```Go
package main

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

type MyIntSlice []int

func main() {
	standardSlice := []int{1, 2, 3}
	customSlice := MyIntSlice{4, 5, 6}

	// lo.Map can accept both standard and custom slice types due to ~[]T constraint
	mappedStandard := lo.Map(standardSlice, func(item int, index int) int {
		return item * 2
	})
	mappedCustom := lo.Map(customSlice, func(item int, index int) int {
		return item * 2
	})

	fmt.Println(mappedStandard) // Output: [2 4 6]
	fmt.Println(mappedCustom)   // Output: [8 10 12]
}
```

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

### SumBy with AVX Variant (Go)

Source: https://lo.samber.dev/docs/experimental/simd

Demonstrates using a specific SIMD variant (SumByUint16x8, an AVX variant) for summing elements from a collection. This variant is designed to work on all amd64 processors. The example sums the 'Value' field from a slice of 'Metric' structs.

```Go
package main

import (
	"fmt"
	"github.com/LAval/simdexp"
)

type Metric struct {
    Value uint16
}

func main() {
    metrics := []Metric{
        {Value: 100},
        {Value: 200},
        {Value: 300},
        {Value: 400},
    }

    // Using AVX variant - works on all amd64
    sum := simdexp.SumByUint16x8(metrics, func(m Metric) uint16 {
        return m.Value
    })
    fmt.Println(sum) // Output: 1000
}
```

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

### Get Random Sample from Collection (Go)

Source: https://lo.samber.dev/docs/iter/find

Returns a random element from a collection. If the collection is empty, it returns the zero value. Requires the 'it' package.

```Go
seq := func(yield func(string) bool) {
    _ = yield("apple")
    _ = yield("banana")
    _ = yield("cherry")
}
item := it.Sample(seq)
// item is randomly one of: "apple", "banana", "cherry"

numbers := func(yield func(int) bool) {
    _ = yield(10)
    _ = yield(20)
    _ = yield(30)
    _ = yield(40)
}
randomNum := it.Sample(numbers)
// randomNum is randomly one of: 10, 20, 30, 40

empty := func(yield func(string) bool) {
    // no yields
}
emptyResult := it.Sample(empty)
// emptyResult: "" (zero value for string)

single := func(yield func(int) bool) {
    _ = yield(42)
}
singleResult := it.Sample(single)
// singleResult: 42 (always returns 42 since it's the only option)
```

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

### Create Integer Slice with Steps (Go)

Source: https://lo.samber.dev/docs/core/math

Generates a slice of integers progressing from a start value up to, but not including, an end value, with a specified step. Returns an empty slice if the step is 0 or if the direction mismatches.

```go
lo.RangeWithSteps(0, 20, 5)
// []int{0, 5, 10, 15}
```

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

### Get Map Keys - lo.Keys

Source: https://lo.samber.dev/docs/core/map

Creates a slice of the map keys. It can accept multiple maps and will include duplicate keys if they appear in different maps. The order of keys is not guaranteed.

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

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
// []string{"foo", "bar", "baz"}

keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3})
// []string{"foo", "bar", "bar"}
```

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

### SumBy with Empty Collection (Go)

Source: https://lo.samber.dev/docs/experimental/simd

Illustrates the behavior of the SumBy function when provided with an empty collection. In such cases, the function correctly returns the zero value for the return type, which is 0 for numeric types. This example uses SumByInt64.

```Go
package main

import (
	"fmt"
	"github.com/LAval/simdexp"
)

type Item struct {
    Count int64
}

func main() {
    // Empty collection returns 0
    sum := simdexp.SumByInt64([]Item{}, func(i Item) int64 {
        return i.Count
    })
    fmt.Println(sum) // Output: 0
}
```

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

### Find Duplicates by CustomerID in Go

Source: https://lo.samber.dev/docs/iter/find

Identifies duplicate orders based on the CustomerID. This example demonstrates finding duplicates in a slice of structs using a specific struct field as the comparison key.

```Go
package main

import (
	"fmt"
	"github.com/<h4>Go</h4>/it"
)

type Order struct {
	CustomerID string
	ProductID  string
}

func main() {
	orders := it.Slice([]Order{
		{CustomerID: "A", ProductID: "1"},
		{CustomerID: "A", ProductID: "2"},
		{CustomerID: "B", ProductID: "1"},
		{CustomerID: "C", ProductID: "3"},
		{CustomerID: "A", ProductID: "3"},
	})

	duplicates := it.FindDuplicatesBy(orders, func(o Order) string { return o.CustomerID })

	fmt.Println("Duplicates by CustomerID:")
	for _, dup := range duplicates {
		fmt.Printf("- %+v\n", dup)
	}
}
```

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

### Slice: Extract a portion of a sequence by start and end indices (Go)

Source: https://lo.samber.dev/docs/iter/slice

Returns a subset of a sequence from a start index up to, but not including, an end index. It takes a collection, a start index, and an end index. The function returns a new sequence containing elements within the specified range. This is analogous to slicing in many programming languages.

```Go
collection := func(yield func(int) bool) {
    yield(1)
    yield(2)
    yield(3)
    yield(4)
    yield(5)
}

sliced := it.Slice(collection, 1, 4)
var result []int
for item := range sliced {
    result = append(result, item)
}
// result contains [2, 3, 4]
```

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

### Partial Application of Functions in Go

Source: https://lo.samber.dev/docs/core/function

Demonstrates how to use the Partial function helper to pre-bind the first argument of a function. This utility is useful for creating specialized versions of existing functions. The example shows adding 10 to a number using a partially applied add function.

```Go
add := func(x, y int) int {
    return x + y
}
add10 := lo.Partial(add, 10)
sum := add10(5)
// sum will be 15
```

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

### HasPrefix: Check if slice starts with a prefix (Go)

Source: https://lo.samber.dev/docs/core/find

Returns true if a collection starts with the given prefix slice. This function is generic and works with any comparable type.

```Go
lo.HasPrefix([]int{1, 2, 3, 4}, []int{1, 2})
// true
```

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

### Convert to camelCase - Go

Source: https://lo.samber.dev/docs/core/string

Converts a string into camelCase, where the first word starts with a lowercase letter and subsequent words start with an uppercase letter, with no separators. Common in JavaScript and other languages.

```Go
package main

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

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

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

### SumBy with Specific SIMD Variant (Go)

Source: https://lo.samber.dev/docs/experimental/simd

Transforms a collection using an iteratee function and sums the result using a specific SIMD instruction set, regardless of CPU capabilities. This example uses the SumByFloat32x8 variant to sum the product of 'Price' and 'Stock' for a slice of 'Product' structs.

```Go
package main

import (
	"fmt"
	"github.com/LAval/simdexp"
)

type Product struct {
    Name  string
    Price float32
    Stock int32
}

func main() {
    products := []Product{
        {Name: "Widget", Price: 10.50, Stock: 5},
        {Name: "Gadget", Price: 20.00, Stock: 3},
        {Name: "Tool", Price: 15.75, Stock: 2},
    }

    // Sum stock value using specific AVX2 variant
    sum := simdexp.SumByFloat32x8(products, func(p Product) float32 {
        return p.Price * float32(p.Stock)
    })
    fmt.Println(sum) // Output: 152.5
}
```

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

### Extract a sub-sequence from a given start and end index

Source: https://lo.samber.dev/docs/iter/sequence

The `Slice` function returns a new sequence containing elements from a specified start index up to (but not including) an end index. It operates on sequences that support iteration. This is useful for selecting portions of a sequence.

```go
result := it.Slice(it.Range(1, 10), 2, 5)
// [3, 4, 5]
```

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

### Extract a slice from start to end (Go)

Source: https://lo.samber.dev/docs/core/slice

Returns a copy of a slice from a specified start index up to, but not including, an end index. This function is similar to Go's built-in slicing but does not panic on index overflow, gracefully handling out-of-bounds indices.

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

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

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

Source: https://lo.samber.dev/docs/about

Demonstrates how to import the main `lo` package and its specialized sub-packages (`parallel`, `mutable`, `it`) in a Go project. This allows access to various utility functions for data manipulation, including unique element extraction.

```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"}
```

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

### Sample Elements Using a Deterministic Function (Go)

Source: https://lo.samber.dev/docs/iter/find

Demonstrates how to use the SamplesBy function to select a specific number of unique elements from a collection using a deterministic function to choose elements. This is useful for testing or when predictable sampling is required.

```Go
package main

import (
	"fmt"
	"github.com/ */}it"
)

func main() {
	// Sample numbers: sequence of 3 random unique numbers
	numbers := it.Slice([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

	// Test with deterministic function
	deterministicFunc := func(max int) int {
		return (max - 1) / 2 // Always return middle index
	}

	samples := it.SamplesBy(numbers, 3, deterministicFunc)

	// samples: sequence with single element from middle
	fmt.Println("Samples:", samples.Slice()) // Example output: [5]
}
```

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

### Slice Sequence

Source: https://lo.samber.dev/docs/iter/sequence

Returns a sub-sequence from start index to end index (exclusive).

```APIDOC
## Slice Sequence

### Description
Returns a sub-sequence from `start` index to `end` index (exclusive).

### Method
N/A (Function Signature)

### Endpoint
N/A (Function Signature)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
result := it.Slice(it.Range(1, 10), 2, 5)
// [3, 4, 5]
```

### Response
#### Success Response (200)
N/A (Function returns a sequence)

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

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

### TakeFilter Example with Go Sequence

Source: https://lo.samber.dev/docs/iter/sequence

This Go code snippet illustrates how to use the TakeFilter function. It takes a sequence generator, a count, and a filter function. The output is a new sequence containing elements that meet the criteria. Dependencies include the 'it' package.

```go
seq := func(yield func(int) bool) {
    yield(1)
    yield(2)
    yield(3)
    yield(4)
    yield(5)
    yield(6)
}
result := it.TakeFilter(seq, 2, func(x int) bool {
    return x%2 == 0
})
var out []int
for v := range result {
    out = append(out, v)
}
// out contains [2, 4]
```

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

### UniqValues Function

Source: https://lo.samber.dev/docs/iter/map

This section details the UniqValues function, its prototype, and usage examples for extracting unique values from maps.

```APIDOC
## UniqValues Function

### Description

The `UniqValues` function is designed to process multiple maps and return a sequence of their unique values. It handles various scenarios, including maps with duplicate values, maps with the same values associated with different keys, and a large number of maps with common and unique values.

### Prototype

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

### Parameters

#### Variadic Parameter `in`

- **map[K]V** - Required - A variable number of maps from which to extract unique values. The key type `K` and value type `V` must be comparable.

### Usage Examples

#### Example 1: Maps with duplicate values

```go
m1 := map[string]int{"a": 10, "b": 20}

m2 := map[string]int{"b": 20, "c": 10} // 10 is duplicate

uniqueValues := it.UniqValues(m1, m2)
// uniqueValues will contain a sequence with 10, 20
```

#### Example 2: Maps with same values from different keys

```go
m1 := map[string]int{
    "key1": 100,
    "key2": 200,
}

m2 := map[string]int{
    "key3": 100,  // Same value as key1
    "key4": 200,  // Same value as key2
    "key5": 300,
}

uniqueValues := it.UniqValues(m1, m2)
// uniqueValues will contain a sequence with 100, 200, 300
```

#### Example 3: Large number of duplicate values

```go
maps := make([]map[int]string, 10)
for i := range maps {
    maps[i] = map[int]string{
        i: "common",  // All maps have the same value
        i + 100: fmt.Sprintf("unique_%d", i),
    }
}

uniqueValues := it.UniqValues(maps...)
// uniqueValues will contain "common" and 10 unique values
```

### Response

#### Success Response (iter.Seq[V])

- **iter.Seq[V]** - A sequence (iterator) yielding the unique values of type `V` found across all input maps.
```

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

### SumBy with Automatic Dispatch (Go)

Source: https://lo.samber.dev/docs/experimental/simd

Transforms a collection using an iteratee function and sums the result using SIMD instructions. The automatic dispatch functions select the best SIMD variant based on CPU capabilities. This example demonstrates summing the 'Age' field from a slice of 'Person' structs.

```Go
package main

import (
	"fmt"
	"github.com/LAval/simdexp"
)

type Person struct {
    Name string
    Age  int8
}

func main() {
    people := []Person{
        {Name: "Alice", Age: 25},
        {Name: "Bob", Age: 30},
        {Name: "Charlie", Age: 35},
    }

    // Automatic dispatch - uses best available SIMD
    sum := simdexp.SumByInt8(people, func(p Person) int8 {
        return p.Age
    })
    fmt.Println(sum) // Output: 90
}
```

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

### Get Random Element from Slice (Go)

Source: https://lo.samber.dev/docs/core/find

Returns a random element from a slice. The behavior is undefined if the slice is empty.

```go
package main

import "github.com/samber/lo"

func main() {
	v := lo.Sample(
	    []int{10, 20, 30},
	)
}
```

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

### Keyify: Create a Set-like Map from Slice in Go

Source: https://lo.samber.dev/docs/core/slice

Returns a map where the keys are the unique elements from the input slice, and the values are empty structs. This effectively creates a set data structure from a slice.

```go
set := lo.Keyify([]int{1, 1, 2, 3, 4})
// map[int]struct{}{1: {}, 2: {}, 3: {}, 4: {}}
```

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

### Go: WithoutBy Function Examples

Source: https://lo.samber.dev/docs/iter/intersect

This Go code demonstrates the use of the `WithoutBy` function to filter a sequence by excluding elements whose extracted keys match any in the exclude list. It provides various examples of excluding elements based on different criteria like age, string length, first letter, modulo, email domain, customer ID, case-insensitive value, month, and custom function results.

```go
// Exclude people by specific ages
type Person struct {
    Name string
    Age  int
}
people := it.Slice([]Person{
    {Name: "Alice", Age: 30},
    {Name: "Bob", Age: 25},
    {Name: "Charlie", Age: 35},
    {Name: "Diana", Age: 30},  // Same age as Alice
})

filtered := it.WithoutBy(people, func(p Person) int { return p.Age }, 30)
// filtered: sequence with Bob (age 25) and Charlie (age 35)

// Exclude strings by their length
words := it.Slice([]string{"hello", "world", "hi", "go", "bye"})
filtered := it.WithoutBy(words, func(s string) int { return len(s) }, 2)
// filtered: sequence with "hello" (5), "world" (5), "bye" (3)
// excludes "hi" and "go" (both length 2)

// Exclude items by first letter
items := it.Slice([]string{"apple", "apricot", "banana", "blueberry", "cherry"})
filtered := it.WithoutBy(items, func(s string) byte { return s[0] }, 'b')
// filtered: sequence with "apple", "apricot", "cherry"
// excludes "banana" and "blueberry" (both start with 'b')

// Exclude numbers by modulo
numbers := it.Slice([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
filtered := it.WithoutBy(numbers, func(n int) int { return n % 3 }, 1)
// filtered: sequence with numbers where n % 3 != 1
// excludes 1, 4, 7, 10 (all have remainder 1)

// Exclude emails by domain
type Email struct {
    Address string
}
emails := it.Slice([]Email{
    {Address: "user1@example.com"},
    {Address: "user2@gmail.com"},
    {Address: "user3@example.com"},
    {Address: "user4@yahoo.com"},
})
filtered := it.WithoutBy(emails, func(e Email) string {
    parts := strings.Split(e.Address, "@")
    if len(parts) > 1 {
        return parts[1]
    }
    return ""
}, "example.com")
// filtered: sequence with gmail.com and yahoo.com emails

// Exclude orders by customer ID
type Order struct {
    ID         string
    CustomerID string
    ProductID  string
}
orders := it.Slice([]Order{
    {ID: "1", CustomerID: "A", ProductID: "X"},
    {ID: "2", CustomerID: "B", ProductID: "Y"},
    {ID: "3", CustomerID: "A", ProductID: "Z"},
    {ID: "4", CustomerID: "C", ProductID: "W"},
})
filtered := it.WithoutBy(orders, func(o Order) string { return o.CustomerID }, "A")
// filtered: sequence with orders from customers B and C

// Exclude strings by case-insensitive value
words := it.Slice([]string{"Hello", "hello", "WORLD", "world", "Go"})
filtered := it.WithoutBy(words, func(s string) string { return strings.ToLower(s) }, "hello")
// filtered: sequence with "WORLD", "world", "Go"
// excludes both "Hello" and "hello" (both become "hello" when lowercased)

// Exclude dates by month
import "time"
dates := it.Slice([]time.Time{
    time.Date(2023, 1, 15, 0, 0, 0, 0, time.UTC),
    time.Date(2023, 2, 20, 0, 0, 0, 0, time.UTC),
    time.Date(2023, 1, 25, 0, 0, 0, 0, time.UTC),
    time.Date(2023, 3, 10, 0, 0, 0, 0, time.UTC),
})
filtered := it.WithoutBy(dates, func(t time.Time) time.Month { return t.Month() }, time.January)
// filtered: sequence with February and March dates

// Exclude multiple values
numbers := it.Slice([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
filtered := it.WithoutBy(numbers, func(n int) int { return n % 2 }, 0, 1)
// filtered: empty sequence (all numbers are either even (0) or odd (1))

// Exclude by custom function result
type Product struct {
    Name  string
    Price float64
}
products := it.Slice([]Product{
    {Name: "Book", Price: 19.99},
    {Name: "Pen", Price: 1.99},
    {Name: "Laptop", Price: 999.99},
    {Name: "Pencil", Price: 0.99},
})
// Exclude products with price < $10
filtered := it.WithoutBy(products, func(p Product) string {
    if p.Price < 10 {
        return "cheap"
    }
    return "expensive"
}, "cheap")
```

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

### Empty - Get Zero Value

Source: https://lo.samber.dev/docs/core/type

Returns the zero value for the specified type. This is useful when you need an empty value of a specific type.

```APIDOC
## Empty

### Description
Returns the zero value for the specified type. This is useful when you need an empty value of a specific type.

### Method
N/A (Function Call)

### Endpoint
N/A

### Parameters
#### Type Parameters
- **T** - The type for which to return the zero value.

### Request Example
```go
result := lo.Empty[string]()  
// "" (zero value for string)

result = lo.Empty[int]()  
// 0 (zero value for int)

result = lo.Empty[[]int]()  
// []int{} (zero value for slice)

result = lo.Empty[map[string]int]()  
// map[string]int{} (zero value for map)

result = lo.Empty[*int]()  
// nil (zero value for pointer)
```

### Response
#### Success Response
- **T** (type) - The zero value of the specified type T.

#### Response Example
```go
// For lo.Empty[string](): ""
// For lo.Empty[int](): 0
// For lo.Empty[[]int](): []int{}
// For lo.Empty[map[string]int](): map[string]int{}
// For lo.Empty[*int](): nil
```
```

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

### Channel Dispatching Strategies (Go)

Source: https://lo.samber.dev/docs/core/channel

Provides various strategies for distributing messages across multiple channels. These include round-robin, random, weighted random, first available, least loaded, and most loaded. Each strategy determines which channel a message should be sent to based on different criteria.

```Go
strategy := lo.DispatchingStrategyRoundRobin[int]
index := strategy(42, 0, []chan int{ch1, ch2, ch3})
// Returns 0, then 1, then 2, then 0, cycling through channels
```

```Go
strategy := lo.DispatchingStrategyRandom[int]
index := strategy(42, 0, []chan int{ch1, ch2, ch3})
// Returns a random channel index 0, 1, or 2
```

```Go
weights := []int{1, 3, 6} // Channel 0: 10%, Channel 1: 30%, Channel 2: 60%
strategy := lo.DispatchingStrategyWeightedRandom[int](weights)
index := strategy(42, 0, []chan int{ch1, ch2, ch3})
// Returns 2 most often, 1 sometimes, 0 rarely
```

```Go
strategy := lo.DispatchingStrategyFirst[int]
index := strategy(42, 0, []chan int{ch1, ch2, ch3})
// Always returns 0 if ch1 is not full
```

```Go
strategy := lo.DispatchingStrategyLeast[int]
index := strategy(42, 0, []chan int{ch1, ch2, ch3})
// Returns the index of the channel with the smallest buffer size
```

```Go
strategy := lo.DispatchingStrategyMost[int]
index := strategy(42, 0, []chan int{ch1, ch2, ch3})
// Returns the index of the channel with the largest buffer size
```

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

### Find Duplicates by Case-Insensitive String in Go

Source: https://lo.samber.dev/docs/iter/find

Finds duplicate strings in a slice, ignoring case. This example uses `strings.ToLower` to normalize strings before checking for duplicates.

```Go
package main

import (
	"fmt"
	"strings"
	"github.com/<h4>Go</h4>/it"
)

func main() {
	words := it.Slice([]string{"Hello", "hello", "WORLD", "world", "Go", "GO", "go"})
	duplicates := it.FindDuplicatesBy(words, func(s string) string { return strings.ToLower(s) })

	fmt.Println("Duplicates by Case-Insensitive Comparison:")
	for _, dup := range duplicates {
		fmt.Printf("- %s\n", dup)
	}
}
```

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

### Find Minimum Value using SIMD (Go)

Source: https://lo.samber.dev/docs/experimental/simd

Finds the minimum value in a collection using SIMD instructions. The suffix (x2, x4, x8, x16, x32, x64) indicates the number of lanes processed simultaneously. Choose the variant matching your CPU's capabilities; higher lane counts offer better performance but require newer CPU support. Empty collections return 0.

```Go
package main

import (
	"fmt"
	"github.com/lo_samber_dev/simdexp"
)

func main() {
	// Using AVX2 variant (32 lanes at once) - Intel Haswell+ / AMD Excavator+
	minInt8 := simdexp.MinInt8x32([]int8{5, 2, 8, 1, 9})
	fmt.Printf("Minimum of int8: %v\n", minInt8) // Output: 1

	// Using AVX-512 variant (16 lanes at once) - Intel Skylake-X+
	minFloat32 := simdexp.MinFloat32x16([]float32{3.5, 1.2, 4.8, 2.1})
	fmt.Printf("Minimum of float32: %v\n", minFloat32) // Output: 1.2

	// Using AVX variant (4 lanes at once) - works on all amd64
	minInt32 := simdexp.MinInt32x4([]int32{100, 50, 200, 75})
	fmt.Printf("Minimum of int32: %v\n", minInt32) // Output: 50

	// Empty collection returns 0
	minUint16 := simdexp.MinUint16x8([]uint16{})
	fmt.Printf("Minimum of empty uint16 slice: %v\n", minUint16) // Output: 0
}
```

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

### Import samber/lo into Global Namespace (Not Recommended)

Source: https://lo.samber.dev/docs/about

Shows an unconventional method to import the entire `lo` library into the global namespace using a blank identifier. This is discouraged due to potential namespace pollution and reduced code clarity, but can be used to avoid repeating `lo.` prefixes.

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

// Now you can use functions directly, e.g.:
// names := Uniq([]string{"Samuel", "John", "Samuel"})
```

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

### CoalesceOrEmpty - Get First Non-Zero or Zero Value

Source: https://lo.samber.dev/docs/core/type

Returns the first non-zero value from the provided comparable arguments, or the zero value if all arguments are zero.

```APIDOC
## CoalesceOrEmpty

### Description
Returns the first non-zero value from the provided comparable arguments, or the zero value if all arguments are zero.

### Method
N/A (Function Call)

### Endpoint
N/A

### Parameters
#### Type Parameters
- **T** - A comparable type.
#### Arguments
- **values** (...T) - A variadic list of values to check.

### Request Example
```go
result := lo.CoalesceOrEmpty("", "foo", "bar")
// "foo"

result = lo.CoalesceOrEmpty("", "")
// ""

result = lo.CoalesceOrEmpty(0, 42, 100)
// 42

result = lo.CoalesceOrEmpty(0.0, 3.14, 2.71)
// 3.14

var s *string
str := "hello"
result = lo.CoalesceOrEmpty(nil, &str)
// &str

result = lo.CoalesceOrEmpty[*string](nil, nil, nil)
// nil
```

### Response
#### Success Response
- **T** - The first non-zero value found, or the zero value if all arguments were zero.

#### Response Example
```go
// For lo.CoalesceOrEmpty("", "foo", "bar"): "foo"
// For lo.CoalesceOrEmpty("", ""): ""
// For lo.CoalesceOrEmpty(0, 42, 100): 42
// For lo.CoalesceOrEmpty(0.0, 3.14, 2.71): 3.14
// For lo.CoalesceOrEmpty(nil, &str): &str
// For lo.CoalesceOrEmpty[*string](nil, nil, nil): nil
```
```

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

### Capitalize

Source: https://lo.samber.dev/docs/core/string

Converts the first character to uppercase and the remaining to lowercase.

```APIDOC
## Capitalize

### Description
Converts the first character to uppercase and the remaining to lowercase.

### Method
N/A (Function call)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
lo.Capitalize("heLLO")
// "Hello"
```

### Response
#### Success Response (200)
string - The capitalized string.

#### Response Example
```json
{
  "example": "Hello"
}
```
```

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

### Coalesce - Get First Non-Zero Value

Source: https://lo.samber.dev/docs/core/type

Returns the first non-zero value from the provided comparable arguments, with a boolean indicating if a non-zero value was found.

```APIDOC
## Coalesce

### Description
Returns the first non-zero value from the provided comparable arguments, with a boolean indicating if a non-zero value was found.

### Method
N/A (Function Call)

### Endpoint
N/A

### Parameters
#### Type Parameters
- **T** - A comparable type.
#### Arguments
- **values** (...T) - A variadic list of values to check.

### Request Example
```go
// With strings - returns first non-empty string
result, ok := lo.Coalesce("", "foo", "bar")
// result: "foo", ok: true

// All zero values - returns zero value with false
result, ok = lo.Coalesce("", "")
// result: "", ok: false

// With integers - zero is considered zero value
result, ok = lo.Coalesce(0, 42, 100)
// result: 42, ok: true

// With floats - zero is considered zero value
result, ok = lo.Coalesce(0.0, 3.14, 2.71)
// result: 3.14, ok: true

// With pointers - nil is zero value for pointer types
var s *string
str := "hello"
result, ok = lo.Coalesce(nil, &str)
// result: &str, ok: true

// All nil pointers
result, ok = lo.Coalesce[*string](nil, nil, nil)
// result: nil, ok: false
```

### Response
#### Success Response
- **T** - The first non-zero value found, or the zero value if all arguments were zero.
- **bool** - True if a non-zero value was found, false otherwise.

#### Response Example
```go
// For lo.Coalesce("", "foo", "bar"): ("foo", true)
// For lo.Coalesce("", ""): ("", false)
// For lo.Coalesce(0, 42, 100): (42, true)
// For lo.Coalesce(0.0, 3.14, 2.71): (3.14, true)
// For lo.Coalesce(nil, &str): (&str, true)
// For lo.Coalesce[*string](nil, nil, nil): (nil, false)
```
```

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

### Convert to PascalCase - Go

Source: https://lo.samber.dev/docs/core/string

Converts a string into PascalCase, where the first letter of each word is capitalized and there are no separators. Useful for naming conventions in programming.

```Go
package main

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

func main() {
	pascal := lo.PascalCase("hello_world")
	fmt.Println(pascal) // "HelloWorld"
}
```

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

### Substring

Source: https://lo.samber.dev/docs/core/string

Returns a substring starting at the given offset with the specified length. Supports negative offsets; out-of-bounds are clamped. Operates on Unicode runes (characters) and is optimized for zero allocations.

```APIDOC
## Substring

### Description
Returns a substring starting at the given offset with the specified length. Supports negative offsets; out-of-bounds are clamped. Operates on Unicode runes (characters) and is optimized for zero allocations.

### Method
N/A (Function call)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
// Basic usage
result := lo.Substring("hello", 2, 3)
// result: "llo"

// Negative offset - counts from end
result = lo.Substring("hello", -4, 3)
// result: "ell"

// Length longer than string - clamped to available characters
result = lo.Substring("hello", 1, 10)
// result: "ello" (only 4 characters available from position 1)

// Zero length - returns empty string
result = lo.Substring("hello", 1, 0)
// result: ""

// Offset beyond string length - returns empty string
result = lo.Substring("hello", 10, 3)
// result: ""

// With Unicode strings (rune-aware)
result = lo.Substring("héllo", 1, 3)
// result: "él"

// Negative offset with negative values clamped
result = lo.Substring("hello", -10, 3)
// result: "hel" (offset clamped to 0)
```

### Response
#### Success Response (200)
string - The extracted substring.

#### Response Example
```json
{
  "example": "llo"
}
```
```

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

### Sample by Custom RNG in Go

Source: https://lo.samber.dev/docs/iter/find

Demonstrates sampling an element from a sequence using a custom random number generator. The provided RNG always returns 0, effectively selecting the first element of the sequence.

```Go
package main

import (
	"fmt"
	"github.com/emirpasic/gods/iterators/arrayiterator"
	"github.com/emirpasichasic/gods/sequences/arrayseq"
)

func main() {
	// Example usage of SampleBy with a custom RNG
	seq := arrayseq.New("a", "b", "c")
	item := seq.SampleBy(func(max int) int { return 0 })
	fmt.Println(item) // Output: a
}
```

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

### Find Duplicates by Age in Go

Source: https://lo.samber.dev/docs/iter/find

Identifies duplicate people in a slice based on their age. This example showcases finding duplicates in a slice of custom structs using a simple field.

```Go
package main

import (
	"fmt"
	"github.com/<h4>Go</h4>/it"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	people := it.Slice([]Person{
		{Name: "Alice", Age: 30},
		{Name: "Bob", Age: 25},
		{Name: "Charlie", Age: 30},
		{Name: "David", Age: 25},
	})

	duplicates := it.FindDuplicatesBy(people, func(p Person) int { return p.Age })

	fmt.Println("Duplicates by Age:")
	for _, dup := range duplicates {
		fmt.Printf("- %+v\n", dup)
	}
}
```

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

### Sum Collection Values using SIMD (Go)

Source: https://lo.samber.dev/docs/experimental/simd

Sums the values in a collection using SIMD instructions. The suffix indicates the number of lanes processed simultaneously. Choose the variant matching your CPU's capabilities for optimal performance. Higher lane counts require newer CPU support.

```go
// Using AVX2 variant (32 lanes at once) - Intel Haswell+ / AMD Excavator+
sum := simd.SumInt8x32([]int8{1, 2, 3, 4, 5})
// 15
```

```go
// Using AVX-512 variant (16 lanes at once) - Intel Skylake-X+
sum := simd.SumFloat32x16([]float32{1.1, 2.2, 3.3, 4.4})
// 11
```

```go
// Using AVX variant (4 lanes at once) - works on all amd64
sum := simd.SumInt32x4([]int32{1000000, 2000000, 3000000})
// 6000000
```

```go
// Empty collection returns 0
sum := simd.SumUint16x16([]uint16{})
// 0
```

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

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

Source: https://lo.samber.dev/docs/iter/find

The `FirstOr` function returns the first element of an iterator sequence, or a provided fallback value if the sequence is empty. This function iterates at most once.

```Go
package main

import "fmt"

// Assuming 'it' is an imported iterator library

func main() {
	// Example with integers
	numbers := it.Slice([]int{5, 2, 8, 1, 9})
	firstInt := it.FirstOr(numbers, 42)
	fmt.Printf("First int or fallback: %d\n", firstInt) // Output: First int or fallback: 5

	emptyInts := it.Slice([]int{})
	firstEmptyInt := it.FirstOr(emptyInts, 42)
	fmt.Printf("First from empty int or fallback: %d\n", firstEmptyInt) // Output: First from empty int or fallback: 42

	// Example with strings
	words := it.Slice([]string{"hello", "world", "go"})
	firstWord := it.FirstOr(words, "fallback")
	fmt.Printf("First word or fallback: %s\n", firstWord) // Output: First word or fallback: hello

	emptyWords := it.Slice([]string{})
	firstEmptyWord := it.FirstOr(emptyWords, "fallback")
	fmt.Printf("First from empty string or fallback: %s\n", firstEmptyWord) // Output: First from empty string or fallback: fallback

	// Example with structs
	type Person struct {
		Name string
		Age  int
	}

	people := it.Slice([]Person{
		{Name: "Alice", Age: 30},
		{Name: "Bob", Age: 25},
	})
	defaultPerson := Person{Name: "Default", Age: 0}
	firstPerson := it.FirstOr(people, defaultPerson)
	fmt.Printf("First person or fallback: %+v\n", firstPerson) // Output: First person or fallback: {Name:"Alice" Age:30}

	emptyPeople := it.Slice([]Person{})
	firstEmptyPerson := it.FirstOr(emptyPeople, defaultPerson)
	fmt.Printf("First from empty person or fallback: %+v\n", firstEmptyPerson) // Output: First from empty person or fallback: {Name:"Default" Age:0}
}
```

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

### FindDuplicates: Get duplicated elements from a sequence (Go)

Source: https://lo.samber.dev/docs/iter/find

Returns a sequence containing the first occurrence of each element that appears more than once in the original collection. This function identifies and returns duplicated items.

```Go
seq := func(yield func(int) bool) {
    _ = yield(1)
    _ = yield(2)
    _ = yield(2)
    _ = yield(3)
    _ = yield(4)
    _ = yield(4)
    _ = yield(4)
}
dupSeq := it.FindDuplicates(seq)
var result []int
for v := range dupSeq {
    result = append(result, v)
}
// result contains 2, 4 (first occurrence of each duplicated element)
```

```Go
seq := func(yield func(string) bool) {
    _ = yield("apple")
    _ = yield("banana")
    _ = yield("apple")
    _ = yield("cherry")
    _ = yield("banana")
}
dupSeq := it.FindDuplicates(seq)
var result []string
for v := range dupSeq {
    result = append(result, v)
}
// result contains "apple", "banana" (duplicated elements)
```

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

### PascalCase

Source: https://lo.samber.dev/docs/core/string

Converts a string to PascalCase.

```APIDOC
## PascalCase

### Description
Converts a string to PascalCase.

### Method
N/A (Function call)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
lo.PascalCase("hello_world")
// "HelloWorld"
```

### Response
#### Success Response (200)
string - The PascalCase version of the string.

#### Response Example
```json
{
  "example": "HelloWorld"
}
```
```

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

### FindUniques: Get unique elements from a sequence (Go)

Source: https://lo.samber.dev/docs/iter/find

Returns a new sequence containing only the elements that appear exactly once in the original collection. Duplicates are removed, preserving only the unique items.

```Go
seq := func(yield func(int) bool) {
    _ = yield(1)
    _ = yield(2)
    _ = yield(2)
    _ = yield(3)
    _ = yield(4)
    _ = yield(4)
}
uniqueSeq := it.FindUniques(seq)
var result []int
for v := range uniqueSeq {
    result = append(result, v)
}
// result contains 1, 3 (elements that appear only once)
```

```Go
seq := func(yield func(string) bool) {
    _ = yield("apple")
    _ = yield("banana")
    _ = yield("apple")
    _ = yield("cherry")
}
uniqueSeq := it.FindUniques(seq)
var result []string
for v := range uniqueSeq {
    result = append(result, v)
}
// result contains "banana", "cherry" (unique elements)
```
Tokens:
Raw