slicekit

package
v0.263.0 Latest Latest
Warning

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

 Go to latest Published: Nov 19, 2024 License: Apache-2.0 Imports: 1 Imported by: 3

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

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 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/slicekit"
)

func main() {
	var x = []string{"a", "b", "c"}
	_ = slicekit.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 Must 

func Must[T any](v T, err error) T
Example 
package main

import (
	"fmt"

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

func main() {
	var x = []int{1, 2, 3}
	x = slicekit.Must(slicekit.MapErr[int](x, func(v int) (int, error) {
		return v * 2, nil
	}))

	v := slicekit.Must(slicekit.ReduceErr[int](x, 42, func(output int, current int) (int, error) {
		return output + current, nil
	}))

	fmt.Println("result:", v)
}

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 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 Reverse added in v0.257.0 

func Reverse[T any](vs []T) iterators.Iterator[T]
Example 
package main

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

func main() {
	var list = []int{1, 2, 3}
	rev := slicekit.Reverse(list)

	for rev.Next() {
		_ = rev.Value() // 3 -> 2 -> 1
	}
}

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 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 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.