funk

README

Benchmarks

BenchmarkMap-16                                      146           8168550 ns/op         8289055 B/op          1 all
BenchmarkUniq-16                                      10         103630461 ns/op        34581937 B/op         23 all
BenchmarkUniqThoas-16                                  4         283696922 ns/op        92759996 B/op    2000015 all
BenchmarkUniqStruct-16                                 6         177865631 ns/op        70916293 B/op         26 all
BenchmarkUniqThoasStruct-16                            3         374595307 ns/op        127689090 B/op   2000018 all
BenchmarkChunk-16                                    111          10232891 ns/op         9581239 B/op      10001 all
BenchmarkChunkReduce-16                               99          11395557 ns/op         9626752 B/op      10001 all
BenchmarkChunkThoas-16                                13         112813206 ns/op        49245217 B/op    1100025 all
BenchmarkDifferenceRandomStruct-16                 75243             13358 ns/op            7366 B/op         30 all
BenchmarkDifferenceThoasRandomStruct-16              470           2306334 ns/op          344273 B/op      20820 all
BenchmarkDifferenceRandom-16                       47986             24955 ns/op           13975 B/op         28 all
BenchmarkDifferenceThoasRandom-16                    868           1476350 ns/op          178580 B/op      20820 all
BenchmarkDifferenceStatic-16                      110392             10376 ns/op            3285 B/op         14 all
BenchmarkDifferenceThoasStatic-16                   1707            719145 ns/op           90498 B/op      10704 all
BenchmarkIntersect-16                              97228             13425 ns/op            5578 B/op         25 all
BenchmarkIntersectThoas-16                         27148             46202 ns/op           15720 B/op        517 all

Documentation

Index

• func All[S ~[]T, T any, F func(T) bool](inp S, pred F) bool
• func Any[S ~[]T, T any, F func(T) bool](inp S, pred F) bool
• func CastSlice[T any, I ~[]any](sl I) ([]T, error)
• func Chunk[S ~[]T, T any](sl S, size int) [][]T
• func Contains[T any](in []T, elem T) bool
• func ContainsFunc[S ~[]T, T any](sl S, pred func(T) bool) bool
• func Difference[S ~[]T, T comparable](left, right S) (inLeft, inRight []T)
• func DifferenceKeyed[S1 ~[]T1, S2 ~[]T2, T1, T2 mdl.Keyed](left S1, right S2) (inLeft S1, inRight S2)
• func DifferenceMaps[K comparable, V1, V2 any, M1 ~map[K]V1, M2 ~map[K]V2](left M1, right M2) (inLeft M1, inRight M2)
• func Empty[S ~[]T, T any](inp S) bool
• func Filter[S ~[]T, T any](sl S, pred func(T) bool) []T
• func FindFirst[S ~[]T, T comparable](sl S, el T) (out T, ok bool)
• func FindFirstFunc[S ~[]T, T any](sl S, pred func(T) bool) (out T, ok bool)
• func First[S ~[]T, T any](sl S) (out T, ok bool)
• func Flatten[S ~[]T, T any](sl []S) []T
• func Index[T any](sl []T, e T) int
• func Intersect[S ~[]T, T comparable](sl1, sl2 S) []T
• func IntersectKeyed[S ~[]T, T mdl.Keyed](s1, s2 S) S
• func IntersectMaps[K comparable, V any, M ~map[K]V](m1, m2 M) M
• func KeyedToMap[S ~[]T, T mdl.Keyed](sl S) map[string]T
• func Last[T any](sl []T) T
• func Map[S ~[]T1, T1, T2 any, F func(T1) T2](sl S, op F) []T2
• func MapKeys[K1 comparable, K2 comparable, V any, M1 ~map[K1]V](m M1, f func(key K1) K2) map[K2]V
• func MapValues[K comparable, V1, V2 any, M1 ~map[K]V1](m M1, f func(value V1) V2) map[K]V2
• func MergeMaps[K comparable, V any, M ~map[K]V](m ...M) M
• func None[S ~[]T, T any, F func(T) bool](inp S, pred F) bool
• func NotEmpty[S ~[]T, T any](inp S) bool
• func Partition[S ~[]T, T any, E comparable, F func(T) E](sl S, keyer F) map[E][]T
• func PartitionMap[S ~[]T, T, K comparable, V any, F func(T) (K, V)](inp S, keyer F) map[K][]V
• func Reduce[S ~[]T1, T1, T2 any](sl S, op func(T2, T1, int) T2, init T2) T2
• func Repeat[T any](el T, times int) []T
• func Reverse[S ~[]T, T any](sl S) S
• func SetToSlice[T comparable](s Set[T]) []T
• func SliceToMap[S ~[]T, T, V any, K comparable](sl S, keyer func(T) (K, V)) map[K]V
• func Tail[T any](sl []T) []T
• func Uniq[S ~[]T, T comparable](sl S) S
• func UniqByType[S ~[]T, T any](sl S) S
• type Set
  • func SliceToSet[S ~[]T, T comparable](sl S) Set[T]
  • func (s Set[T]) Contains(item T) bool
  • func (s Set[T]) Set(item T)

Functions

func All

func All[S ~[]T, T any, F func(T) bool](inp S, pred F) bool

func Any

func Any[S ~[]T, T any, F func(T) bool](inp S, pred F) bool

func CastSlice

func CastSlice[T any, I ~[]any](sl I) ([]T, error)

CastSlice casts a []any slice to the given type. The parameter sliceType is required to correctly infer the target type.

func Chunk

func Chunk[S ~[]T, T any](sl S, size int) [][]T

func Contains

func Contains[T any](in []T, elem T) bool

func ContainsFunc

func ContainsFunc[S ~[]T, T any](sl S, pred func(T) bool) bool

func Difference

func Difference[S ~[]T, T comparable](left, right S) (inLeft, inRight []T)

func DifferenceKeyed

func DifferenceKeyed[S1 ~[]T1, S2 ~[]T2, T1, T2 mdl.Keyed](left S1, right S2) (inLeft S1, inRight S2)

func DifferenceMaps

func DifferenceMaps[K comparable, V1, V2 any, M1 ~map[K]V1, M2 ~map[K]V2](left M1, right M2) (inLeft M1, inRight M2)

func Empty

func Empty[S ~[]T, T any](inp S) bool

func Filter

func Filter[S ~[]T, T any](sl S, pred func(T) bool) []T

func FindFirst

func FindFirst[S ~[]T, T comparable](sl S, el T) (out T, ok bool)

func FindFirstFunc

func FindFirstFunc[S ~[]T, T any](sl S, pred func(T) bool) (out T, ok bool)

func First

func First[S ~[]T, T any](sl S) (out T, ok bool)

func Flatten

func Flatten[S ~[]T, T any](sl []S) []T

func Index

func Index[T any](sl []T, e T) int

func Intersect

func Intersect[S ~[]T, T comparable](sl1, sl2 S) []T

func IntersectKeyed

func IntersectKeyed[S ~[]T, T mdl.Keyed](s1, s2 S) S

func IntersectMaps

func IntersectMaps[K comparable, V any, M ~map[K]V](m1, m2 M) M

func KeyedToMap

func KeyedToMap[S ~[]T, T mdl.Keyed](sl S) map[string]T

func Last

func Last[T any](sl []T) T

func Map

func Map[S ~[]T1, T1, T2 any, F func(T1) T2](sl S, op F) []T2

func MapKeys

func MapKeys[K1 comparable, K2 comparable, V any, M1 ~map[K1]V](m M1, f func(key K1) K2) map[K2]V

func MapValues

func MapValues[K comparable, V1, V2 any, M1 ~map[K]V1](m M1, f func(value V1) V2) map[K]V2

func MergeMaps

func MergeMaps[K comparable, V any, M ~map[K]V](m ...M) M

func None

func None[S ~[]T, T any, F func(T) bool](inp S, pred F) bool

func NotEmpty

func NotEmpty[S ~[]T, T any](inp S) bool

func Partition

func Partition[S ~[]T, T any, E comparable, F func(T) E](sl S, keyer F) map[E][]T

func PartitionMap

func PartitionMap[S ~[]T, T, K comparable, V any, F func(T) (K, V)](inp S, keyer F) map[K][]V

func Reduce

func Reduce[S ~[]T1, T1, T2 any](sl S, op func(T2, T1, int) T2, init T2) T2

func Repeat

func Repeat[T any](el T, times int) []T

func Reverse

func Reverse[S ~[]T, T any](sl S) S

func SetToSlice

func SetToSlice[T comparable](s Set[T]) []T

func SliceToMap

func SliceToMap[S ~[]T, T, V any, K comparable](sl S, keyer func(T) (K, V)) map[K]V

func Tail

func Tail[T any](sl []T) []T

func Uniq

func Uniq[S ~[]T, T comparable](sl S) S

func UniqByType

func UniqByType[S ~[]T, T any](sl S) S

Types

type Set

type Set[T comparable] map[T]struct{}

func SliceToSet

func SliceToSet[S ~[]T, T comparable](sl S) Set[T]

func (Set[T]) Contains

func (s Set[T]) Contains(item T) bool

func (Set[T]) Set

func (s Set[T]) Set(item T)