Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

funk

package module

Go to main page

Versions in this module

v0

v0.8.3

Apr 28, 2021

v0.8.2

Apr 4, 2021

Changes in this version

+ func GetAllowZero(out interface{}, path string) interface

v0.8.1

Apr 4, 2021

Changes in this version

+ func AllPredicates(value interface{}, predicates interface{}) bool

+ func AnyPredicates(value interface{}, predicates interface{}) bool

+ func ContainsUInt(s []uint, v uint) bool

+ func ContainsUInt32(s []uint32, v uint32) bool

+ func ContainsUInt64(s []uint64, v uint64) bool

+ func Difference(x interface{}, y interface{}) (interface{}, interface{})

+ func DifferenceInt(x []int, y []int) ([]int, []int)

+ func DifferenceInt32(x []int32, y []int32) ([]int32, []int32)

+ func DifferenceInt64(x []int64, y []int64) ([]int64, []int64)

+ func DifferenceString(x []string, y []string) ([]string, []string)

+ func DifferenceUInt(x []uint, y []uint) ([]uint, []uint)

+ func DifferenceUInt32(x []uint32, y []uint32) ([]uint32, []uint32)

+ func DifferenceUInt64(x []uint64, y []uint64) ([]uint64, []uint64)

+ func DropUInt(s []uint, n uint) []uint

+ func DropUInt32(s []uint32, n int) []uint32

+ func DropUInt64(s []uint64, n int) []uint64

+ func FilterUInt(s []uint, cb func(s uint) bool) []uint

+ func FilterUInt32(s []uint32, cb func(s uint32) bool) []uint32

+ func FilterUInt64(s []uint64, cb func(s uint64) bool) []uint64

+ func FindKey(arr interface{}, predicate interface{}) (matchKey, matchEle interface{})

+ func FlatMap(arr interface{}, mapFunc interface{}) interface

+ func Flatten(out interface{}) interface

+ func GetOrElse(v interface{}, def interface{}) interface

+ func InUInt32s(s []uint32, v uint32) bool

+ func InUInt64s(s []uint64, v uint64) bool

+ func InUInts(s []uint, v uint) bool

+ func IndexOfUInt(a []uint, x uint) int

+ func IndexOfUInt32(a []uint32, x uint32) int

+ func IndexOfUInt64(a []uint64, x uint64) int

+ func InnerJoin(lx, rx reflect.Value) reflect.Value

+ func InnerJoinFloat32(lx, rx []float32) []float32

+ func InnerJoinFloat64(lx, rx []float64) []float64

+ func InnerJoinInt(lx, rx []int) []int

+ func InnerJoinInt32(lx, rx []int32) []int32

+ func InnerJoinInt64(lx, rx []int64) []int64

+ func InnerJoinString(lx, rx []string) []string

+ func IsPredicate(in interface{}, inTypes ...reflect.Type) bool

+ func Join(larr, rarr interface{}, fnc JoinFnc) interface

+ func JoinFloat32(larr, rarr []float32, fnc JoinFloat32Fnc) []float32

+ func JoinFloat64(larr, rarr []float64, fnc JoinFloat64Fnc) []float64

+ func JoinInt(larr, rarr []int, fnc JoinIntFnc) []int

+ func JoinInt32(larr, rarr []int32, fnc JoinInt32Fnc) []int32

+ func JoinInt64(larr, rarr []int64, fnc JoinInt64Fnc) []int64

+ func JoinString(larr, rarr []string, fnc JoinStringFnc) []string

+ func LastIndexOfUInt(a []uint, x uint) int

+ func LastIndexOfUInt32(a []uint32, x uint32) int

+ func LastIndexOfUInt64(a []uint64, x uint64) int

+ func LeftJoin(lx, rx reflect.Value) reflect.Value

+ func LeftJoinFloat32(lx, rx []float32) []float32

+ func LeftJoinFloat64(lx, rx []float64) []float64

+ func LeftJoinInt(lx, rx []int) []int

+ func LeftJoinInt32(lx, rx []int32) []int32

+ func LeftJoinInt64(lx, rx []int64) []int64

+ func LeftJoinString(lx, rx []string) []string

+ func MaxFloat32(i []float32) interface

+ func MaxFloat64(i []float64) interface

+ func MaxInt(i []int) interface

+ func MaxInt16(i []int16) interface

+ func MaxInt32(i []int32) interface

+ func MaxInt64(i []int64) interface

+ func MaxInt8(i []int8) interface

+ func MaxString(i []string) interface

+ func MinFloat32(i []float32) interface

+ func MinFloat64(i []float64) interface

+ func MinInt(i []int) interface

+ func MinInt16(i []int16) interface

+ func MinInt32(i []int32) interface

+ func MinInt64(i []int64) interface

+ func MinInt8(i []int8) interface

+ func MinString(i []string) interface

+ func MustSet(in interface{}, val interface{}, path string)

+ func NextPermutation(nums []int) error

+ func OuterJoin(lx, rx reflect.Value) reflect.Value

+ func OuterJoinFloat32(lx, rx []float32) []float32

+ func OuterJoinFloat64(lx, rx []float64) []float64

+ func OuterJoinInt(lx, rx []int) []int

+ func OuterJoinInt32(lx, rx []int32) []int32

+ func OuterJoinInt64(lx, rx []int64) []int64

+ func OuterJoinString(lx, rx []string) []string

+ func Prune(in interface{}, paths []string) (interface{}, error)

+ func PruneByTag(in interface{}, paths []string, tag string) (interface{}, error)

+ func ReverseUInt(s []uint) []uint

+ func ReverseUInt32(s []uint32) []uint32

+ func ReverseUInt64(s []uint64) []uint64

+ func RightJoin(lx, rx reflect.Value) reflect.Value

+ func RightJoinFloat32(lx, rx []float32) []float32

+ func RightJoinFloat64(lx, rx []float64) []float64

+ func RightJoinInt(lx, rx []int) []int

+ func RightJoinInt32(lx, rx []int32) []int32

+ func RightJoinInt64(lx, rx []int64) []int64

+ func RightJoinString(lx, rx []string) []string

+ func Set(in interface{}, val interface{}, path string) error

+ func ShortIf(condition bool, a interface{}, b interface{}) interface

+ func ShuffleUInt(a []uint) []uint

+ func ShuffleUInt32(a []uint32) []uint32

+ func ShuffleUInt64(a []uint64) []uint64

+ func Some(in interface{}, elements ...interface{}) bool

+ func Subset(x interface{}, y interface{}) bool

+ func Subtract(x interface{}, y interface{}) interface

+ func SubtractString(x []string, y []string) []string

+ func SumUInt(s []uint) (sum uint)

+ func SumUInt32(s []uint32) (sum uint32)

+ func SumUInt64(s []uint64) (sum uint64)

+ func UniqUInt(a []uint) []uint

+ func UniqUInt32(a []uint32) []uint32

+ func UniqUInt64(a []uint64) []uint64

+ func Without(in interface{}, values ...interface{}) interface

type Builder

+ FlatMap func(mapFunc interface{}) Builder

+ Flatten func() Builder

+ Join func(rarr interface{}, fnc JoinFnc) Builder

+ Without func(values ...interface{}) Builder

+ type JoinFloat32Fnc func(lx, rx []float32) []float32

+ type JoinFloat64Fnc func(lx, rx []float64) []float64

+ type JoinFnc func(lx, rx reflect.Value) reflect.Value

+ type JoinInt32Fnc func(lx, rx []int32) []int32

+ type JoinInt64Fnc func(lx, rx []int64) []int64

+ type JoinIntFnc func(lx, rx []int) []int

+ type JoinStringFnc func(lx, rx []string) []string

v0.4.0

Apr 7, 2019

v0.3.0

Apr 7, 2019

v0.2.0

Apr 7, 2019

v0.1.0

Apr 7, 2019

Changes in this version

+ func All(objs ...interface{}) bool

+ func Any(objs ...interface{}) bool

+ func Chunk(arr interface{}, size int) interface

+ func Compact(value interface{}) interface

+ func Contains(in interface{}, elem interface{}) bool

+ func ContainsFloat32(s []float32, v float32) bool

+ func ContainsFloat64(s []float64, v float64) bool

+ func ContainsInt(s []int, v int) bool

+ func ContainsInt32(s []int32, v int32) bool

+ func ContainsInt64(s []int64, v int64) bool

+ func ContainsString(s []string, v string) bool

+ func ConvertSlice(in interface{}, out interface{})

+ func Drop(in interface{}, n int) interface

+ func DropFloat32(s []float32, n int) []float32

+ func DropFloat64(s []float64, n int) []float64

+ func DropInt(s []int, n int) []int

+ func DropInt32(s []int32, n int) []int32

+ func DropInt64(s []int64, n int) []int64

+ func DropString(s []string, n int) []string

+ func Equal(expected interface{}, actual interface{}) bool

+ func Every(in interface{}, elements ...interface{}) bool

+ func Fill(in interface{}, fillValue interface{}) (interface{}, error)

+ func Filter(arr interface{}, predicate interface{}) interface

+ func FilterFloat32(s []float32, cb func(s float32) bool) []float32

+ func FilterFloat64(s []float64, cb func(s float64) bool) []float64

+ func FilterInt(s []int, cb func(s int) bool) []int

+ func FilterInt32(s []int32, cb func(s int32) bool) []int32

+ func FilterInt64(s []int64, cb func(s int64) bool) []int64

+ func FilterString(s []string, cb func(s string) bool) []string

+ func Find(arr interface{}, predicate interface{}) interface

+ func FindFloat32(s []float32, cb func(s float32) bool) (float32, bool)

+ func FindFloat64(s []float64, cb func(s float64) bool) (float64, bool)

+ func FindInt(s []int, cb func(s int) bool) (int, bool)

+ func FindInt32(s []int32, cb func(s int32) bool) (int32, bool)

+ func FindInt64(s []int64, cb func(s int64) bool) (int64, bool)

+ func FindString(s []string, cb func(s string) bool) (string, bool)

+ func FlattenDeep(out interface{}) interface

+ func ForEach(arr interface{}, predicate interface{})

+ func ForEachRight(arr interface{}, predicate interface{})

+ func Get(out interface{}, path string) interface

+ func Head(arr interface{}) interface

+ func InFloat32s(s []float32, v float32) bool

+ func InFloat64s(s []float64, v float64) bool

+ func InInt32s(s []int32, v int32) bool

+ func InInt64s(s []int64, v int64) bool

+ func InInts(s []int, v int) bool

+ func InStrings(s []string, v string) bool

+ func IndexOf(in interface{}, elem interface{}) int

+ func IndexOfFloat64(a []float64, x float64) int

+ func IndexOfInt(a []int, x int) int

+ func IndexOfInt32(a []int32, x int32) int

+ func IndexOfInt64(a []int64, x int64) int

+ func IndexOfString(a []string, x string) int

+ func Initial(arr interface{}) interface

+ func Intersect(x interface{}, y interface{}) interface

+ func IntersectString(x []string, y []string) []string

+ func IsCollection(in interface{}) bool

+ func IsEmpty(obj interface{}) bool

+ func IsEqual(expected interface{}, actual interface{}) bool

+ func IsFunction(in interface{}, num ...int) bool

+ func IsIteratee(in interface{}) bool

+ func IsType(expected interface{}, actual interface{}) bool

+ func IsZero(obj interface{}) bool

+ func Keys(out interface{}) interface

+ func Last(arr interface{}) interface

+ func LastIndexOf(in interface{}, elem interface{}) int

+ func LastIndexOfFloat32(a []float32, x float32) int

+ func LastIndexOfFloat64(a []float64, x float64) int

+ func LastIndexOfInt(a []int, x int) int

+ func LastIndexOfInt32(a []int32, x int32) int

+ func LastIndexOfInt64(a []int64, x int64) int

+ func LastIndexOfString(a []string, x string) int

+ func Map(arr interface{}, mapFunc interface{}) interface

+ func NotEmpty(obj interface{}) bool

+ func NotEqual(expected interface{}, actual interface{}) bool

+ func Product(arr interface{}) float64

+ func PtrOf(itf interface{}) interface

+ func RandomInt(min, max int) int

+ func RandomString(n int, allowedChars ...[]rune) string

+ func Reduce(arr, reduceFunc, acc interface{}) float64

+ func Reverse(in interface{}) interface

+ func ReverseFloat32(s []float32) []float32

+ func ReverseFloat64(s []float64) []float64

+ func ReverseInt(s []int) []int

+ func ReverseInt32(s []int32) []int32

+ func ReverseInt64(s []int64) []int64

+ func ReverseString(s string) string

+ func ReverseStrings(s []string) []string

+ func Shard(str string, width int, depth int, restOnly bool) []string

+ func Shuffle(in interface{}) interface

+ func ShuffleFloat32(a []float32) []float32

+ func ShuffleFloat64(a []float64) []float64

+ func ShuffleInt(a []int) []int

+ func ShuffleInt32(a []int32) []int32

+ func ShuffleInt64(a []int64) []int64

+ func ShuffleString(a []string) []string

+ func SliceOf(in interface{}) interface

+ func Sum(arr interface{}) float64

+ func SumFloat32(s []float32) (sum float32)

+ func SumFloat64(s []float64) (sum float64)

+ func SumInt(s []int) (sum int)

+ func SumInt32(s []int32) (sum int32)

+ func SumInt64(s []int64) (sum int64)

+ func Tail(arr interface{}) interface

+ func ToFloat64(x interface{}) (float64, bool)

+ func ToMap(in interface{}, pivot string) interface

+ func Uniq(in interface{}) interface

+ func UniqFloat32(a []float32) []float32

+ func UniqFloat64(a []float64) []float64

+ func UniqInt(a []int) []int

+ func UniqInt32(a []int32) []int32

+ func UniqInt64(a []int64) []int64

+ func UniqString(a []string) []string

+ func Values(out interface{}) interface

+ func ZeroOf(in interface{}) interface

+ type Builder interface

+ All func() bool

+ Any func() bool

+ Chunk func(size int) Builder

+ Compact func() Builder

+ Contains func(elem interface{}) bool

+ Drop func(n int) Builder

+ Every func(elements ...interface{}) bool

+ Filter func(predicate interface{}) Builder

+ Find func(predicate interface{}) interface{}

+ FlattenDeep func() Builder

+ ForEach func(predicate interface{})

+ ForEachRight func(predicate interface{})

+ Head func() interface{}

+ IndexOf func(elem interface{}) int

+ Initial func() Builder

+ Intersect func(y interface{}) Builder

+ IsEmpty func() bool

+ Keys func() interface{}

+ Last func() interface{}

+ LastIndexOf func(elem interface{}) int

+ Map func(mapFunc interface{}) Builder

+ NotEmpty func() bool

+ Product func() float64

+ Reduce func(reduceFunc, acc interface{}) float64

+ Reverse func() Builder

+ Shuffle func() Builder

+ Sum func() float64

+ Tail func() Builder

+ Type func() reflect.Type

+ Uniq func() Builder

+ Value func() interface{}

+ Values func() interface{}

+ func Chain(v interface{}) Builder

+ func LazyChain(v interface{}) Builder

+ func LazyChainWith(generator func() interface{}) Builder

+ type Tuple struct

+ Element1 interface{}

+ Element2 interface{}

+ func Zip(slice1 interface{}, slice2 interface{}) []Tuple