slicekit

package
v0.285.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 8, 2025 License: Apache-2.0 Imports: 2 Imported by: 3

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AnyOf added in v0.267.0 

func AnyOf[T any](vs []T, filter func(T) bool) bool

func Batch added in v0.217.0 

func Batch[T any](vs []T, size int) [][]T
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	vs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}

	batches := slicekit.Batch(vs, 5)
	_ = batches
	// 0 -> []int{1, 2, 3, 4, 5}
	// 1 -> []int{6, 7, 8, 9, 10}
	// 2 -> []int{11, 12, 13, 14, 15}
}

func Clone added in v0.198.0 

func Clone[T any](src []T) []T

Clone creates a clone from passed src slice.

Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var (
		src = []string{"a", "b", "c"}
		dst = slicekit.Clone(src)
	)
	_, _ = src, dst
}

func Contains added in v0.212.0 

func Contains[T comparable](s []T, v T) bool

Contains reports if a slice contains a given value.

Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	_ = slicekit.Contains([]string{"foo", "bar", "baz"}, "bar") // true
	_ = slicekit.Contains([]int{7, 42, 128}, 128)               // true
	_ = slicekit.Contains([]int{7, 42, 128}, 32)                // false
}

func Filter added in v0.200.0 

func Filter[T any](src []T, filter func(v T) bool) []T
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var (
		src = []string{"a", "b", "c"}
		dst = slicekit.Filter(src, func(s string) bool {
			return s != "c"
		})
	)
	_ = dst // []string{"a", "b"}, nil
}

func FilterErr added in v0.226.0 

func FilterErr[T any](src []T, filter func(v T) (bool, error)) ([]T, error)
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var (
		src      = []string{"a", "b", "c"}
		dst, err = slicekit.FilterErr[string](src, func(s string) (bool, error) {
			return s != "c", nil
		})
	)
	_, _ = dst, err // []string{"a", "b"}, nil
}

func Find added in v0.270.0 

func Find[T any](vs []T, by func(T) bool) (T, bool)

Find will find the first matching element in a slice based on the "by" filter function.

Example 
package main

import (
	"time"

	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	type Person struct {
		Name     string
		Birthday time.Time
	}

	var ps []Person

	person, ok := slicekit.Find(ps, func(p Person) bool {
		return p.Birthday.After(time.Date(2000, 1, 1, 12, 00, 00, 00, time.UTC))
	})

	_, _ = person, ok
}

func First added in v0.274.0 

func First[T any](vs []T) (T, bool)

func GroupBy added in v0.272.0 

func GroupBy[T any, ID comparable](vs []T, by func(v T) ID) map[ID][]T

GroupBy will group values in []T based on the group indetifier function.

Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

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

	groups := slicekit.GroupBy(vs, func(n int) string {
		if n%2 == 0 {
			return "even"
		}
		return "odd"
	})

	_ = groups
}

func Insert added in v0.263.0 

func Insert[T any](vs *[]T, index int, nvs ...T)

func Last added in v0.257.0 

func Last[T any](vs []T) (T, bool)
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list = []int{1, 2, 3}
	last, ok := slicekit.Last(list)
	_ = ok   // true
	_ = last // 3
}
Example (OnEmpty) 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list = []string{}
	last, ok := slicekit.Last(list)
	_ = ok   // false
	_ = last // ""
}
Example (OnNil) 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list []byte
	last, ok := slicekit.Last(list)
	_ = ok   // false
	_ = last // 0
}

func Lookup added in v0.186.0 

func Lookup[T any](vs []T, index int) (T, bool)
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	vs := []int{2, 4, 8, 16}
	slicekit.Lookup(vs, 0)      // -> return 2, true
	slicekit.Lookup(vs, 0-1)    // lookup previous -> return 0, false
	slicekit.Lookup(vs, 0+1)    // lookup next -> return 4, true
	slicekit.Lookup(vs, 0+1000) // lookup 1000th element -> return 0, false
}

func Map 

func Map[O, I any](s []I, mapper func(I) O) []O

Map will do a mapping from an input type into an output type.

Example 
package main

import (
	"strconv"
	"strings"

	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var x = []string{"a", "b", "c"}
	_ = slicekit.Map(x, strings.ToUpper) // []string{"A", "B", "C"}

	var ns = []string{"1", "2", "3"}
	_, err := slicekit.MapErr[int](ns, strconv.Atoi) // []int{1, 2, 3}
	if err != nil {
		panic(err)
	}
}

func MapErr added in v0.226.0 

func MapErr[O, I any](s []I, mapper func(I) (O, error)) ([]O, error)

MapErr will do a mapping from an input type into an output type.

Example 
package main

import (
	"strconv"
	"strings"

	"go.llib.dev/frameless/pkg/must"
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var x = []string{"a", "b", "c"}
	_ = must.Must(slicekit.MapErr[string](x, func(s string) (string, error) {
		return strings.ToUpper(s), nil
	})) // []string{"A", "B", "C"}

	var ns = []string{"1", "2", "3"}
	_, err := slicekit.MapErr[int](ns, strconv.Atoi) // []int{1, 2, 3}
	if err != nil {
		panic(err)
	}
}

func Merge added in v0.188.0 

func Merge[T any](slices ...[]T) []T

Merge will merge every []T slice into a single one.

Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var (
		a   = []string{"a", "b", "c"}
		b   = []string{"1", "2", "3"}
		c   = []string{"1", "B", "3"}
		out = slicekit.Merge(a, b, c)
	)
	_ = out // []string{"a", "b", "c", "1", "2", "3", "1", "B", "3"}
}

func Pop added in v0.257.0 

func Pop[T any](vs *[]T) (T, bool)
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list = []int{1, 2, 3}

	v, ok := slicekit.Pop(&list)
	_ = ok   // true
	_ = v    // 3
	_ = list // []int{1, 2}
}
Example (OnEmpty) 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list = []string{}

	v, ok := slicekit.Pop(&list)
	_ = ok   // false
	_ = v    // ""
	_ = list // []string{}
}
Example (OnNil) 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list []byte

	v, ok := slicekit.Pop(&list)
	_ = ok   // false
	_ = v    // 0
	_ = list // ([]byte)(nil)
}

func PopAt added in v0.277.0 

func PopAt[T any](vs *[]T, index int) (T, bool)

func Reduce 

func Reduce[O, I any](s []I, initial O, reducer func(O, I) O) O

Reduce iterates over a slice, combining elements using the reducer function.

Example 
package main

import (
	"fmt"
	"strconv"

	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var x = []int{1, 2, 3}
	got := slicekit.Reduce[string](x, "|", func(s string, i int) string {
		return s + strconv.Itoa(i)
	})
	fmt.Println(got) // "|123"
}

func ReduceErr added in v0.226.0 

func ReduceErr[O, I any](s []I, initial O, reducer func(O, I) (O, error)) (O, error)

ReduceErr iterates over a slice, combining elements using the reducer function.

Example 
package main

import (
	"fmt"

	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var x = []string{"a", "b", "c"}
	got, err := slicekit.ReduceErr[string](x, "|", func(o string, i string) (string, error) {
		return o + i, nil
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(got) // "|abc"
}

func Shift added in v0.257.0 

func Shift[T any](vs *[]T) (T, bool)
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list = []int{1, 2, 3}

	v, ok := slicekit.Shift(&list)
	_ = ok   // true
	_ = v    // 1
	_ = list // []int{2, 3}
}
Example (OnEmpty) 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list = []string{}

	v, ok := slicekit.Shift(&list)
	_ = ok   // false
	_ = v    // ""
	_ = list // []string{}
}
Example (OnNil) 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list []byte

	v, ok := slicekit.Shift(&list)
	_ = ok   // false
	_ = v    // 0
	_ = list // ([]byte)(nil)
}

func SortBy added in v0.274.0 

func SortBy[T any](vs []T, less func(a, b T) bool)

func Unique added in v0.233.0 

func Unique[T comparable](vs []T) []T
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	slicekit.Unique([]int{1, 2, 2, 3, 3, 3})
	// -> []int{1, 2, 3}
}

func UniqueBy added in v0.269.0 

func UniqueBy[T any, ID comparable](vs []T, by func(T) ID) []T
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	type T struct {
		ID  int
		Val string
	}
	vs := []T{
		{ID: 1, Val: "foo1"},
		{ID: 2, Val: "bar1"},
		{ID: 2, Val: "bar2"},
		{ID: 3, Val: "baz1"},
		{ID: 3, Val: "baz2"},
		{ID: 3, Val: "baz3"},
	}
	slicekit.UniqueBy(vs, func(v T) int { return v.ID })
	// []T{
	//   {ID: 1, Val: "foo1"},
	//   {ID: 2, Val: "bar1"},
	//   {ID: 3, Val: "baz1"},
	// }
}

func Unshift added in v0.257.0 

func Unshift[T any](vs *[]T, nvs ...T)
Example 
package main

import (
	"go.llib.dev/frameless/pkg/slicekit"
)

func main() {
	var list []string
	_ = list // ([]string)(nil)
	slicekit.Unshift(&list, "foo")
	_ = list // []string{"foo"}
	slicekit.Unshift(&list, "bar")
	_ = list // []string{"bar", "foo"}
	slicekit.Unshift(&list, "baz", "qux")
	_ = list // []string{"baz", "qux", "bar", "foo"}
}

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.