README

go-funk
=======

.. image:: https://secure.travis-ci.org/thoas/go-funk.svg?branch=master
    :alt: Build Status
    :target: http://travis-ci.org/thoas/go-funk

.. image:: https://godoc.org/github.com/thoas/go-funk?status.svg
    :alt: GoDoc
    :target: https://godoc.org/github.com/thoas/go-funk

.. image:: https://goreportcard.com/badge/github.com/thoas/go-funk
    :alt: Go report
    :target: https://goreportcard.com/report/github.com/thoas/go-funk

``go-funk`` is a modern Go library based on reflect_.

Generic helpers rely on reflect_, be careful this code runs exclusively on runtime so you must have a good test suite.

These helpers have started as an experiment to learn reflect_. It may look like lodash_ in some aspects but
it will have its own roadmap. lodash_ is an awesome library with a lot of work behind it, all features included in
``go-funk`` come from internal use cases.

You can also find typesafe implementation in the godoc_.

Why this name?
--------------

Long story, short answer because ``func`` is a reserved word in Go, I wanted something similar.

Initially this project was named ``fn`` I don't need to explain why that was a bad idea for french speakers :)

Let's ``funk``!

.. image:: https://media.giphy.com/media/3oEjHQKtDXpeGN9rW0/giphy.gif

<3

Installation
------------

.. code-block:: bash

    go get github.com/thoas/go-funk

Usage
-----

.. code-block:: go

    import "github.com/thoas/go-funk"

These examples will be based on the following data model:

.. code-block:: go

    type Foo struct {
        ID        int
        FirstName string `tag_name:"tag 1"`
        LastName  string `tag_name:"tag 2"`
        Age       int    `tag_name:"tag 3"`
    }

    func (f Foo) TableName() string {
        return "foo"
    }

With fixtures:

.. code-block:: go

    f := &Foo{
        ID:        1,
        FirstName: "Foo",
        LastName:  "Bar",
        Age:       30,
    }

You can import ``go-funk`` using a basic statement:

.. code-block:: go

    import "github.com/thoas/go-funk"

funk.Contains
.............

Returns true if an element is present in a iteratee (slice, map, string).

One frustrating thing in Go is to implement ``contains`` methods for each type, for example:

.. code-block:: go

    func ContainsInt(s []int, e int) bool {
        for _, a := range s {
            if a == e {
                return true
            }
        }
        return false
    }

this can be replaced by ``funk.Contains``:

.. code-block:: go

    // slice of string
    funk.Contains([]string{"foo", "bar"}, "bar") // true

    // slice of Foo ptr
    funk.Contains([]*Foo{f}, f) // true
    funk.Contains([]*Foo{f}, nil) // false

    b := &Foo{
        ID:        2,
        FirstName: "Florent",
        LastName:  "Messa",
        Age:       28,
    }

    funk.Contains([]*Foo{f}, b) // false

    // string
    funk.Contains("florent", "rent") // true
    funk.Contains("florent", "foo") // false

    // even map
    funk.Contains(map[int]string{1: "Florent"}, 1) // true

see also, typesafe implementations: ContainsInt_, ContainsInt64_, ContainsFloat32_, ContainsFloat64_, ContainsString_

.. _ContainsFloat32: https://godoc.org/github.com/thoas/go-funk#ContainsFloat32
.. _ContainsFloat64: https://godoc.org/github.com/thoas/go-funk#ContainsFloat64
.. _ContainsInt: https://godoc.org/github.com/thoas/go-funk#ContainsInt
.. _ContainsInt64: https://godoc.org/github.com/thoas/go-funk#ContainsInt64
.. _ContainsString: https://godoc.org/github.com/thoas/go-funk#ContainsString

funk.Intersect
..............

Returns the intersection between two collections.

.. code-block:: go

    funk.Intersect([]int{1, 2, 3, 4}, []int{2, 4, 6})  // []int{2, 4}
    funk.Intersect([]string{"foo", "bar", "hello", "bar"}, []string{"foo", "bar"})  // []string{"foo", "bar"}

see also, typesafe implementations: IntersectString

.. IntersectString: https://godoc.org/github.com/thoas/go-funk#IntersectString


funk.Difference
..............

Returns the difference between two collections.

.. code-block:: go

    funk.Difference([]int{1, 2, 3, 4}, []int{2, 4, 6})  // []int{1, 3}, []int{6}
    funk.Difference([]string{"foo", "bar", "hello", "bar"}, []string{"foo", "bar"})  // []string{"hello"}, []string{}

see also, typesafe implementations: DifferenceString

.. DifferenceString: https://godoc.org/github.com/thoas/go-funk#DifferenceString


funk.IndexOf
............

Gets the index at which the first occurrence of a value is found in an array or return -1
if the value cannot be found.

.. code-block:: go

    // slice of string
    funk.IndexOf([]string{"foo", "bar"}, "bar") // 1
    funk.IndexOf([]string{"foo", "bar"}, "gilles") // -1

see also, typesafe implementations: IndexOfInt_, IndexOfInt64_, IndexOfFloat32_, IndexOfFloat64_, IndexOfString_

.. _IndexOfFloat32: https://godoc.org/github.com/thoas/go-funk#IndexOfFloat32
.. _IndexOfFloat64: https://godoc.org/github.com/thoas/go-funk#IndexOfFloat64
.. _IndexOfInt: https://godoc.org/github.com/thoas/go-funk#IndexOfInt
.. _IndexOfInt64: https://godoc.org/github.com/thoas/go-funk#IndexOfInt64
.. _IndexOfString: https://godoc.org/github.com/thoas/go-funk#IndexOfString

funk.LastIndexOf
................

Gets the index at which the last occurrence of a value is found in an array or return -1
if the value cannot be found.

.. code-block:: go

    // slice of string
    funk.LastIndexOf([]string{"foo", "bar", "bar"}, "bar") // 2
    funk.LastIndexOf([]string{"foo", "bar"}, "gilles") // -1

see also, typesafe implementations: LastIndexOfInt_, LastIndexOfInt64_, LastIndexOfFloat32_, LastIndexOfFloat64_, LastIndexOfString_

.. _LastIndexOfFloat32: https://godoc.org/github.com/thoas/go-funk#LastIndexOfFloat32
.. _LastIndexOfFloat64: https://godoc.org/github.com/thoas/go-funk#LastIndexOfFloat64
.. _LastIndexOfInt: https://godoc.org/github.com/thoas/go-funk#LastIndexOfInt
.. _LastIndexOfInt64: https://godoc.org/github.com/thoas/go-funk#LastIndexOfInt64
.. _LastIndexOfString: https://godoc.org/github.com/thoas/go-funk#LastIndexOfString

funk.ToMap
..........

Transforms a slice of structs to a map based on a ``pivot`` field.

.. code-block:: go

    f := &Foo{
        ID:        1,
        FirstName: "Gilles",
        LastName:  "Fabio",
        Age:       70,
    }

    b := &Foo{
        ID:        2,
        FirstName: "Florent",
        LastName:  "Messa",
        Age:       80,
    }

    results := []*Foo{f, b}

    mapping := funk.ToMap(results, "ID") // map[int]*Foo{1: f, 2: b}

funk.Filter
...........

Filters a slice based on a predicate.

.. code-block:: go

    r := funk.Filter([]int{1, 2, 3, 4}, func(x int) bool {
        return x%2 == 0
    }) // []int{2, 4}

see also, typesafe implementations: FilterInt_, FilterInt64_, FilterFloat32_, FilterFloat64_, FilterString_

.. _FilterFloat32: https://godoc.org/github.com/thoas/go-funk#FilterFloat32
.. _FilterFloat64: https://godoc.org/github.com/thoas/go-funk#FilterFloat64
.. _FilterInt: https://godoc.org/github.com/thoas/go-funk#FilterInt
.. _FilterInt64: https://godoc.org/github.com/thoas/go-funk#FilterInt64
.. _FilterString: https://godoc.org/github.com/thoas/go-funk#FilterString

funk.Find
.........

Finds an element in a slice based on a predicate.

.. code-block:: go

    r := funk.Find([]int{1, 2, 3, 4}, func(x int) bool {
        return x%2 == 0
    }) // 2

see also, typesafe implementations: FindInt_, FindInt64_, FindFloat32_, FindFloat64_, FindString_

.. _FindFloat32: https://godoc.org/github.com/thoas/go-funk#FindFloat32
.. _FindFloat64: https://godoc.org/github.com/thoas/go-funk#FindFloat64
.. _FindInt: https://godoc.org/github.com/thoas/go-funk#FindInt
.. _FindInt64: https://godoc.org/github.com/thoas/go-funk#FindInt64
.. _FindString: https://godoc.org/github.com/thoas/go-funk#FindString

funk.Map
........

Manipulates an iteratee (map, slice) and transforms it to another type:

* map -> slice
* map -> map
* slice -> map
* slice -> slice

.. code-block:: go

    r := funk.Map([]int{1, 2, 3, 4}, func(x int) int {
        return x * 2
    }) // []int{2, 4, 6, 8}

    r := funk.Map([]int{1, 2, 3, 4}, func(x int) string {
        return "Hello"
    }) // []string{"Hello", "Hello", "Hello", "Hello"}

    r = funk.Map([]int{1, 2, 3, 4}, func(x int) (int, int) {
        return x, x
    }) // map[int]int{1: 1, 2: 2, 3: 3, 4: 4}

    mapping := map[int]string{
        1: "Florent",
        2: "Gilles",
    }

    r = funk.Map(mapping, func(k int, v string) int {
        return k
    }) // []int{1, 2}

    r = funk.Map(mapping, func(k int, v string) (string, string) {
        return fmt.Sprintf("%d", k), v
    }) // map[string]string{"1": "Florent", "2": "Gilles"}

funk.Get
........

Retrieves the value at path of struct(s).

.. code-block:: go

    var bar *Bar = &Bar{
        Name: "Test",
        Bars: []*Bar{
            &Bar{
                Name: "Level1-1",
                Bar: &Bar{
                    Name: "Level2-1",
                },
            },
            &Bar{
                Name: "Level1-2",
                Bar: &Bar{
                    Name: "Level2-2",
                },
            },
        },
    }

    var foo *Foo = &Foo{
        ID:        1,
        FirstName: "Dark",
        LastName:  "Vador",
        Age:       30,
        Bar:       bar,
        Bars: []*Bar{
            bar,
            bar,
        },
    }

    funk.Get([]*Foo{foo}, "Bar.Bars.Bar.Name") // []string{"Level2-1", "Level2-2"}
    funk.Get(foo, "Bar.Bars.Bar.Name") // []string{"Level2-1", "Level2-2"}
    funk.Get(foo, "Bar.Name") // Test

``funk.Get`` also handles ``nil`` values:

.. code-block:: go

    bar := &Bar{
        Name: "Test",
    }

    foo1 := &Foo{
        ID:        1,
        FirstName: "Dark",
        LastName:  "Vador",
        Age:       30,
        Bar:       bar,
    }

    foo2 := &Foo{
        ID:        1,
        FirstName: "Dark",
        LastName:  "Vador",
        Age:       30,
    } // foo2.Bar is nil

    funk.Get([]*Foo{foo1, foo2}, "Bar.Name") // []string{"Test"}
    funk.Get(foo2, "Bar.Name") // nil



funk.GetOrElse
..............

Retrieves the value of the pointer or default.

.. code-block:: go

    str := "hello world"
    GetOrElse(&str, "foobar")   // string{"hello world"}
    GetOrElse(str, "foobar")    // string{"hello world"}
    GetOrElse(nil, "foobar")    // string{"foobar"}


funk.Keys
.........

Creates an array of the own enumerable map keys or struct field names.

.. code-block:: go

    funk.Keys(map[string]int{"one": 1, "two": 2}) // []string{"one", "two"} (iteration order is not guaranteed)

    foo := &Foo{
        ID:        1,
        FirstName: "Dark",
        LastName:  "Vador",
        Age:       30,
    }

    funk.Keys(foo) // []string{"ID", "FirstName", "LastName", "Age"} (iteration order is not guaranteed)

funk.Values
...........

Creates an array of the own enumerable map values or struct field values.

.. code-block:: go

    funk.Values(map[string]int{"one": 1, "two": 2}) // []string{1, 2} (iteration order is not guaranteed)

    foo := &Foo{
        ID:        1,
        FirstName: "Dark",
        LastName:  "Vador",
        Age:       30,
    }

    funk.Values(foo) // []interface{}{1, "Dark", "Vador", 30} (iteration order is not guaranteed)

funk.ForEach
............

Range over an iteratee (map, slice).

.. code-block:: go

    funk.ForEach([]int{1, 2, 3, 4}, func(x int) {
        fmt.Println(x)
    })

funk.ForEachRight
............

Range over an iteratee (map, slice) from the right.

.. code-block:: go

    results := []int{}

    funk.ForEachRight([]int{1, 2, 3, 4}, func(x int) {
        results = append(results, x)
    })

    fmt.Println(results) // []int{4, 3, 2, 1}

funk.Chunk
..........

Creates an array of elements split into groups with the length of the size.
If array can't be split evenly, the final chunk will be the remaining element.

.. code-block:: go

    funk.Chunk([]int{1, 2, 3, 4, 5}, 2) // [][]int{[]int{1, 2}, []int{3, 4}, []int{5}}

funk.FlattenDeep
................

Recursively flattens an array.

.. code-block:: go

    funk.FlattenDeep([][]int{[]int{1, 2}, []int{3, 4}}) // []int{1, 2, 3, 4}

funk.Uniq
.........

Creates an array with unique values.

.. code-block:: go

    funk.Uniq([]int{0, 1, 1, 2, 3, 0, 0, 12}) // []int{0, 1, 2, 3, 12}

see also, typesafe implementations: UniqInt_, UniqInt64_, UniqFloat32_, UniqFloat64_, UniqString_

.. _UniqFloat32: https://godoc.org/github.com/thoas/go-funk#UniqFloat32
.. _UniqFloat64: https://godoc.org/github.com/thoas/go-funk#UniqFloat64
.. _UniqInt: https://godoc.org/github.com/thoas/go-funk#UniqInt
.. _UniqInt64: https://godoc.org/github.com/thoas/go-funk#UniqInt64
.. _UniqString: https://godoc.org/github.com/thoas/go-funk#UniqString

funk.Drop
.........

Creates an array/slice with `n` elements dropped from the beginning.

.. code-block:: go

    funk.Drop([]int{0, 0, 0, 0}, 3) // []int{0}

see also, typesafe implementations: DropInt_, DropInt32_, DropInt64_, DropFloat32_, DropFloat64_, DropString_

.. _DropInt: https://godoc.org/github.com/thoas/go-funk#DropInt
.. _DropInt32: https://godoc.org/github.com/thoas/go-funk#DropInt64
.. _DropInt64: https://godoc.org/github.com/thoas/go-funk#DropInt64
.. _DropFloat32: https://godoc.org/github.com/thoas/go-funk#DropFloat32
.. _DropFloat64: https://godoc.org/github.com/thoas/go-funk#DropFloat64
.. _DropString: https://godoc.org/github.com/thoas/go-funk#DropString

funk.Initial
............

Gets all but the last element of array.

.. code-block:: go

    funk.Initial([]int{0, 1, 2, 3, 4}) // []int{0, 1, 2, 3}

funk.Tail
.........

Gets all but the first element of array.

.. code-block:: go

    funk.Tail([]int{0, 1, 2, 3, 4}) // []int{1, 2, 3, 4}

funk.Shuffle
............

Creates an array of shuffled values.

.. code-block:: go

    funk.Shuffle([]int{0, 1, 2, 3, 4}) // []int{2, 1, 3, 4, 0}


see also, typesafe implementations: ShuffleInt_, ShuffleInt64_, ShuffleFloat32_, ShuffleFloat64_, ShuffleString_

.. _ShuffleFloat32: https://godoc.org/github.com/thoas/go-funk#ShuffleFloat32
.. _ShuffleFloat64: https://godoc.org/github.com/thoas/go-funk#ShuffleFloat64
.. _ShuffleInt: https://godoc.org/github.com/thoas/go-funk#ShuffleInt
.. _ShuffleInt64: https://godoc.org/github.com/thoas/go-funk#ShuffleInt64
.. _ShuffleString: https://godoc.org/github.com/thoas/go-funk#ShuffleString

funk.Subtract
.............

Returns the subtraction between two collections. It preserve order.

.. code-block:: go

    funk.Subtract([]int{0, 1, 2, 3, 4}, []int{0, 4}) // []int{1, 2, 3}
    funk.Subtract([]int{0, 3, 2, 3, 4}, []int{0, 4}) // []int{3, 2, 3}


see also, typesafe implementations: SubtractString_

.. SubtractString: https://godoc.org/github.com/thoas/go-funk#SubtractString

funk.Sum
........

Computes the sum of the values in an array.

.. code-block:: go

    funk.Sum([]int{0, 1, 2, 3, 4}) // 10.0
    funk.Sum([]interface{}{0.5, 1, 2, 3, 4}) // 10.5

see also, typesafe implementations: SumInt_, SumInt64_, SumFloat32_, SumFloat64_

.. _SumFloat32: https://godoc.org/github.com/thoas/go-funk#SumFloat32
.. _SumFloat64: https://godoc.org/github.com/thoas/go-funk#SumFloat64
.. _SumInt: https://godoc.org/github.com/thoas/go-funk#SumInt
.. _SumInt64: https://godoc.org/github.com/thoas/go-funk#SumInt64

funk.Reverse
............

Transforms an array such that the first element will become the last, the second element
will become the second to last, etc.

.. code-block:: go

    funk.Reverse([]int{0, 1, 2, 3, 4}) // []int{4, 3, 2, 1, 0}

see also, typesafe implementations: ReverseInt_, ReverseInt64_, ReverseFloat32_, ReverseFloat64_, ReverseString_, ReverseStrings_

.. _ReverseFloat32: https://godoc.org/github.com/thoas/go-funk#ReverseFloat32
.. _ReverseFloat64: https://godoc.org/github.com/thoas/go-funk#ReverseFloat64
.. _ReverseInt: https://godoc.org/github.com/thoas/go-funk#ReverseInt
.. _ReverseInt64: https://godoc.org/github.com/thoas/go-funk#ReverseInt64
.. _ReverseString: https://godoc.org/github.com/thoas/go-funk#ReverseString
.. _ReverseStrings: https://godoc.org/github.com/thoas/go-funk#ReverseStrings

funk.SliceOf
............

Returns a slice based on an element.

.. code-block:: go

    funk.SliceOf(f) // will return a []*Foo{f}

funk.RandomInt
..............

Generates a random int, based on a min and max values.

.. code-block:: go

    funk.RandomInt(0, 100) // will be between 0 and 100

funk.RandomString
.................

Generates a random string with a fixed length.

.. code-block:: go

    funk.RandomString(4) // will be a string of 4 random characters

funk.Shard
..........

Generates a sharded string with a fixed length and depth.

.. code-block:: go

    funk.Shard("e89d66bdfdd4dd26b682cc77e23a86eb", 1, 2, false) // []string{"e", "8", "e89d66bdfdd4dd26b682cc77e23a86eb"}

    funk.Shard("e89d66bdfdd4dd26b682cc77e23a86eb", 2, 2, false) // []string{"e8", "9d", "e89d66bdfdd4dd26b682cc77e23a86eb"}

    funk.Shard("e89d66bdfdd4dd26b682cc77e23a86eb", 2, 2, true) // []string{"e8", "9d", "66", "bdfdd4dd26b682cc77e23a86eb"}

funk.Subset
.............

Returns true if a collection is a subset of another 

.. code-block:: go

    funk.Subset([]int{1, 2, 4}, []int{1, 2, 3, 4, 5}) // true
    funk.Subset([]string{"foo", "bar"},[]string{"foo", "bar", "hello", "bar", "hi"}) //true
   
    
Performance
-----------

``go-funk`` currently has an open issue about performance_, don't hesitate to participate in the discussion
to enhance the generic helpers implementations.

Let's stop beating around the bush, a typesafe implementation in pure Go of ``funk.Contains``, let's say for example:

.. code-block:: go

    func ContainsInt(s []int, e int) bool {
        for _, a := range s {
            if a == e {
                return true
            }
        }
        return false
    }

will always outperform an implementation based on reflect_ in terms of speed and allocs because of
how it's implemented in the language.

If you want a similarity, gorm_ will always be slower than sqlx_ (which is very low level btw) and will use more allocs.

You must not think generic helpers of ``go-funk`` as a replacement when you are dealing with performance in your codebase,
you should use typesafe implementations instead.

Contributing
------------

* Ping me on twitter `@thoas <https://twitter.com/thoas>`_ (DMs, mentions, whatever :))
* Fork the `project <https://github.com/thoas/go-funk>`_
* Fix `open issues <https://github.com/thoas/go-funk/issues>`_ or request new features

Don't hesitate ;)

Authors
-------

* Florent Messa
* Gilles Fabio
* Alexey Pokhozhaev
* Alexandre Nicolaie

.. _reflect: https://golang.org/pkg/reflect/
.. _lodash: https://lodash.com/
.. _performance: https://github.com/thoas/go-funk/issues/19
.. _gorm: https://github.com/jinzhu/gorm
.. _sqlx: https://github.com/jmoiron/sqlx
.. _godoc: https://godoc.org/github.com/thoas/go-funk
Expand ▾ Collapse ▴

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func All

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

    All returns true if all elements of the iterable are not empty (or if the iterable is empty)

    func Any

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

      Any returns true if any element of the iterable is not empty. If the iterable is empty, return False.

      func Chunk

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

        Chunk creates an array of elements split into groups with the length of size. If array can't be split evenly, the final chunk will be the remaining element.

        func Compact

        func Compact(value interface{}) interface{}

          Compact creates a slice with all empty/zero values removed.

          func Contains

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

            Contains returns true if an element is present in a iteratee.

            func ContainsFloat32

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

              ContainsFloat32 returns true if a float32 is present in a iteratee.

              func ContainsFloat64

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

                ContainsFloat64 returns true if a float64 is present in a iteratee.

                func ContainsInt

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

                  ContainsInt returns true if an int is present in a iteratee.

                  func ContainsInt32

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

                    ContainsInt32 returns true if an int32 is present in a iteratee.

                    func ContainsInt64

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

                      ContainsInt64 returns true if an int64 is present in a iteratee.

                      func ContainsString

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

                        ContainsString returns true if a string is present in a iteratee.

                        func ConvertSlice

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

                          ConvertSlice converts a slice type to another, a perfect example would be to convert a slice of struct to a slice of interface.

                          func Difference

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

                            Difference returns the difference between two collections.

                            func DifferenceString

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

                              DifferenceString returns the difference between two collections of strings.

                              func Drop

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

                                Drop creates an array/slice with `n` elements dropped from the beginning.

                                func DropFloat32

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

                                  DropFloat32 creates a slice with `n` float32s dropped from the beginning.

                                  func DropFloat64

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

                                    DropFloat64 creates a slice with `n` float64s dropped from the beginning.

                                    func DropInt

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

                                      DropInt creates a slice with `n` ints dropped from the beginning.

                                      func DropInt32

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

                                        DropInt32 creates a slice with `n` int32s dropped from the beginning.

                                        func DropInt64

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

                                          DropInt64 creates a slice with `n` int64s dropped from the beginning.

                                          func DropString

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

                                            DropString creates a slice with `n` strings dropped from the beginning.

                                            func Equal

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

                                              Equal returns if the two objects are equal

                                              func Every

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

                                                Every returns true if every element is present in a iteratee.

                                                func Fill

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

                                                  Fill fills elements of array with value

                                                  func Filter

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

                                                    Filter iterates over elements of collection, returning an array of all elements predicate returns truthy for.

                                                    func FilterFloat32

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

                                                      FilterFloat32 iterates over a collection of float32, returning an array of all float32 elements predicate returns truthy for.

                                                      func FilterFloat64

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

                                                        FilterFloat64 iterates over a collection of float64, returning an array of all float64 elements predicate returns truthy for.

                                                        func FilterInt

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

                                                          FilterInt iterates over a collection of int, returning an array of all int elements predicate returns truthy for.

                                                          func FilterInt32

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

                                                            FilterInt32 iterates over a collection of int32, returning an array of all int32 elements predicate returns truthy for.

                                                            func FilterInt64

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

                                                              FilterInt64 iterates over a collection of int64, returning an array of all int64 elements predicate returns truthy for.

                                                              func FilterString

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

                                                                FilterString iterates over a collection of string, returning an array of all string elements predicate returns truthy for.

                                                                func Find

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

                                                                  Find iterates over elements of collection, returning the first element predicate returns truthy for.

                                                                  func FindFloat32

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

                                                                    FindFloat32 iterates over a collection of float32, returning the first float32 element predicate returns truthy for.

                                                                    func FindFloat64

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

                                                                      FindFloat64 iterates over a collection of float64, returning an array of all float64 elements predicate returns truthy for.

                                                                      func FindInt

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

                                                                        FindInt iterates over a collection of int, returning the first int element predicate returns truthy for.

                                                                        func FindInt32

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

                                                                          FindInt32 iterates over a collection of int32, returning the first int32 element predicate returns truthy for.

                                                                          func FindInt64

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

                                                                            FindInt64 iterates over a collection of int64, returning the first int64 element predicate returns truthy for.

                                                                            func FindKey

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

                                                                              Find iterates over elements of collection, returning the first element of an array and random of a map which predicate returns truthy for.

                                                                              func FindString

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

                                                                                FindString iterates over a collection of string, returning the first string element predicate returns truthy for.

                                                                                func FlattenDeep

                                                                                func FlattenDeep(out interface{}) interface{}

                                                                                  FlattenDeep recursively flattens array.

                                                                                  func ForEach

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

                                                                                    ForEach iterates over elements of collection and invokes iteratee for each element.

                                                                                    func ForEachRight

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

                                                                                      ForEachRight iterates over elements of collection from the right and invokes iteratee for each element.

                                                                                      func Get

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

                                                                                        Get retrieves the value at path of struct(s).

                                                                                        func GetOrElse

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

                                                                                          Get retrieves the value of the pointer or default.

                                                                                          func Head(arr interface{}) interface{}

                                                                                            Head gets the first element of array.

                                                                                            func InFloat32s

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

                                                                                              InFloat32s is an alias of ContainsFloat32, returns true if a float32 is present in a iteratee.

                                                                                              func InFloat64s

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

                                                                                                InFloat64s is an alias of ContainsFloat64, returns true if a float64 is present in a iteratee.

                                                                                                func InInt32s

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

                                                                                                  InInt32s is an alias of ContainsInt32, returns true if an int32 is present in a iteratee.

                                                                                                  func InInt64s

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

                                                                                                    InInt64s is an alias of ContainsInt64, returns true if an int64 is present in a iteratee.

                                                                                                    func InInts

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

                                                                                                      InInts is an alias of ContainsInt, returns true if an int is present in a iteratee.

                                                                                                      func InStrings

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

                                                                                                        InStrings is an alias of ContainsString, returns true if a string is present in a iteratee.

                                                                                                        func IndexOf

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

                                                                                                          IndexOf gets the index at which the first occurrence of value is found in array or return -1 if the value cannot be found

                                                                                                          func IndexOfFloat64

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

                                                                                                            IndexOfFloat64 gets the index at which the first occurrence of an float64 value is found in array or return -1 if the value cannot be found

                                                                                                            func IndexOfInt

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

                                                                                                              IndexOfInt gets the index at which the first occurrence of an int value is found in array or return -1 if the value cannot be found

                                                                                                              func IndexOfInt32

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

                                                                                                                IndexOfInt32 gets the index at which the first occurrence of an int32 value is found in array or return -1 if the value cannot be found

                                                                                                                func IndexOfInt64

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

                                                                                                                  IndexOfInt64 gets the index at which the first occurrence of an int64 value is found in array or return -1 if the value cannot be found

                                                                                                                  func IndexOfString

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

                                                                                                                    IndexOfString gets the index at which the first occurrence of a string value is found in array or return -1 if the value cannot be found

                                                                                                                    func Initial

                                                                                                                    func Initial(arr interface{}) interface{}

                                                                                                                      Initial gets all but the last element of array.

                                                                                                                      func InnerJoin

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

                                                                                                                        InnerJoin finds and returns matching data from two collections.

                                                                                                                        func InnerJoinFloat32

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

                                                                                                                          InnerJoinFloat32 finds and returns matching data from two float32 collections.

                                                                                                                          func InnerJoinFloat64

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

                                                                                                                            InnerJoinFloat64 finds and returns matching data from two float64 collections.

                                                                                                                            func InnerJoinInt

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

                                                                                                                              InnerJoinInt finds and returns matching data from two int collections.

                                                                                                                              func InnerJoinInt32

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

                                                                                                                                InnerJoinInt32 finds and returns matching data from two int32 collections.

                                                                                                                                func InnerJoinInt64

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

                                                                                                                                  InnerJoinInt64 finds and returns matching data from two int64 collections.

                                                                                                                                  func InnerJoinString

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

                                                                                                                                    InnerJoinString finds and returns matching data from two string collections.

                                                                                                                                    func Intersect

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

                                                                                                                                      Intersect returns the intersection between two collections.

                                                                                                                                      Deprecated: use Join(x, y, InnerJoin) instead of Intersect, InnerJoin implements deduplication mechanism, so verify your code behaviour before using it

                                                                                                                                      func IntersectString

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

                                                                                                                                        IntersectString returns the intersection between two collections of string.

                                                                                                                                        func IsCollection

                                                                                                                                        func IsCollection(in interface{}) bool

                                                                                                                                          IsCollection returns if the argument is a collection.

                                                                                                                                          func IsEmpty

                                                                                                                                          func IsEmpty(obj interface{}) bool

                                                                                                                                            IsEmpty returns if the object is considered as empty or not.

                                                                                                                                            func IsEqual

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

                                                                                                                                              IsEqual returns if the two objects are equal

                                                                                                                                              func IsFunction

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

                                                                                                                                                IsFunction returns if the argument is a function.

                                                                                                                                                func IsIteratee

                                                                                                                                                func IsIteratee(in interface{}) bool

                                                                                                                                                  IsIteratee returns if the argument is an iteratee.

                                                                                                                                                  func IsType

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

                                                                                                                                                    IsType returns if the two objects are in the same type

                                                                                                                                                    func IsZero

                                                                                                                                                    func IsZero(obj interface{}) bool

                                                                                                                                                      IsZero returns if the object is considered as zero value

                                                                                                                                                      func Join

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

                                                                                                                                                        Join combines two collections using the given join method.

                                                                                                                                                        func JoinFloat32

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

                                                                                                                                                          JoinFloat32 combines two float32 collections using the given join method.

                                                                                                                                                          func JoinFloat64

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

                                                                                                                                                            JoinFloat64 combines two float64 collections using the given join method.

                                                                                                                                                            func JoinInt

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

                                                                                                                                                              JoinInt combines two int collections using the given join method.

                                                                                                                                                              func JoinInt32

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

                                                                                                                                                                JoinInt32 combines two int32 collections using the given join method.

                                                                                                                                                                func JoinInt64

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

                                                                                                                                                                  JoinInt64 combines two int64 collections using the given join method.

                                                                                                                                                                  func JoinString

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

                                                                                                                                                                    JoinString combines two string collections using the given join method.

                                                                                                                                                                    func Keys

                                                                                                                                                                    func Keys(out interface{}) interface{}

                                                                                                                                                                      Keys creates an array of the own enumerable map keys or struct field names.

                                                                                                                                                                      func Last

                                                                                                                                                                      func Last(arr interface{}) interface{}

                                                                                                                                                                        Last gets the last element of array.

                                                                                                                                                                        func LastIndexOf

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

                                                                                                                                                                          LastIndexOf gets the index at which the last occurrence of value is found in array or return -1 if the value cannot be found

                                                                                                                                                                          func LastIndexOfFloat32

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

                                                                                                                                                                            LastIndexOfFloat32 gets the index at which the first occurrence of an float32 value is found in array or return -1 if the value cannot be found

                                                                                                                                                                            func LastIndexOfFloat64

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

                                                                                                                                                                              LastIndexOfFloat64 gets the index at which the first occurrence of an float64 value is found in array or return -1 if the value cannot be found

                                                                                                                                                                              func LastIndexOfInt

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

                                                                                                                                                                                LastIndexOfInt gets the index at which the first occurrence of an int value is found in array or return -1 if the value cannot be found

                                                                                                                                                                                func LastIndexOfInt32

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

                                                                                                                                                                                  LastIndexOfInt32 gets the index at which the first occurrence of an int32 value is found in array or return -1 if the value cannot be found

                                                                                                                                                                                  func LastIndexOfInt64

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

                                                                                                                                                                                    LastIndexOfInt64 gets the index at which the first occurrence of an int64 value is found in array or return -1 if the value cannot be found

                                                                                                                                                                                    func LastIndexOfString

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

                                                                                                                                                                                      LastIndexOfString gets the index at which the first occurrence of a string value is found in array or return -1 if the value cannot be found

                                                                                                                                                                                      func LeftJoin

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

                                                                                                                                                                                        LeftJoin finds and returns dissimilar data from the first collection (left).

                                                                                                                                                                                        func LeftJoinFloat32

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

                                                                                                                                                                                          LeftJoinFloat32 finds and returns dissimilar data from the first float32 collection (left).

                                                                                                                                                                                          func LeftJoinFloat64

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

                                                                                                                                                                                            LeftJoinFloat64 finds and returns dissimilar data from the first float64 collection (left).

                                                                                                                                                                                            func LeftJoinInt

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

                                                                                                                                                                                              LeftJoinInt finds and returns dissimilar data from the first int collection (left).

                                                                                                                                                                                              func LeftJoinInt32

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

                                                                                                                                                                                                LeftJoinInt32 finds and returns dissimilar data from the first int32 collection (left).

                                                                                                                                                                                                func LeftJoinInt64

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

                                                                                                                                                                                                  LeftJoinInt64 finds and returns dissimilar data from the first int64 collection (left).

                                                                                                                                                                                                  func LeftJoinString

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

                                                                                                                                                                                                    LeftJoinString finds and returns dissimilar data from the first string collection (left).

                                                                                                                                                                                                    func Map

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

                                                                                                                                                                                                      Map manipulates an iteratee and transforms it to another type.

                                                                                                                                                                                                      func MaxFloat32

                                                                                                                                                                                                      func MaxFloat32(i []float32) interface{}

                                                                                                                                                                                                        MaxFloat32 validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []float32 It returns float32 or nil It returns nil for the following cases:

                                                                                                                                                                                                        - input is of length 0
                                                                                                                                                                                                        

                                                                                                                                                                                                        func MaxFloat64

                                                                                                                                                                                                        func MaxFloat64(i []float64) interface{}

                                                                                                                                                                                                          MaxFloat64 validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []float64 It returns float64 or nil It returns nil for the following cases:

                                                                                                                                                                                                          - input is of length 0
                                                                                                                                                                                                          

                                                                                                                                                                                                          func MaxInt

                                                                                                                                                                                                          func MaxInt(i []int) interface{}

                                                                                                                                                                                                            MaxInt validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []int It returns int or nil It returns nil for the following cases:

                                                                                                                                                                                                            - input is of length 0
                                                                                                                                                                                                            

                                                                                                                                                                                                            func MaxInt16

                                                                                                                                                                                                            func MaxInt16(i []int16) interface{}

                                                                                                                                                                                                              MaxInt16 validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []int16 It returns int16 or nil It returns nil for the following cases:

                                                                                                                                                                                                              - input is of length 0
                                                                                                                                                                                                              

                                                                                                                                                                                                              func MaxInt32

                                                                                                                                                                                                              func MaxInt32(i []int32) interface{}

                                                                                                                                                                                                                MaxInt32 validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []int32 It returns int32 or nil It returns nil for the following cases:

                                                                                                                                                                                                                - input is of length 0
                                                                                                                                                                                                                

                                                                                                                                                                                                                func MaxInt64

                                                                                                                                                                                                                func MaxInt64(i []int64) interface{}

                                                                                                                                                                                                                  MaxInt64 validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []int64 It returns int64 or nil It returns nil for the following cases:

                                                                                                                                                                                                                  - input is of length 0
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  func MaxInt8

                                                                                                                                                                                                                  func MaxInt8(i []int8) interface{}

                                                                                                                                                                                                                    MaxInt8 validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []int8 It returns int8 or nil It returns nil for the following cases:

                                                                                                                                                                                                                    - input is of length 0
                                                                                                                                                                                                                    

                                                                                                                                                                                                                    func MaxString

                                                                                                                                                                                                                    func MaxString(i []string) interface{}

                                                                                                                                                                                                                      MaxString validates the input, compares the elements and returns the maximum element in an array/slice. It accepts []string It returns string or nil It returns nil for the following cases:

                                                                                                                                                                                                                      - input is of length 0
                                                                                                                                                                                                                      

                                                                                                                                                                                                                      func MinFloat32

                                                                                                                                                                                                                      func MinFloat32(i []float32) interface{}

                                                                                                                                                                                                                        MinFloat32 validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []float32 It returns float32 or nil It returns nil for the following cases:

                                                                                                                                                                                                                        - input is of length 0
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        func MinFloat64

                                                                                                                                                                                                                        func MinFloat64(i []float64) interface{}

                                                                                                                                                                                                                          MinFloat64 validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []float64 It returns float64 or nil It returns nil for the following cases:

                                                                                                                                                                                                                          - input is of length 0
                                                                                                                                                                                                                          

                                                                                                                                                                                                                          func MinInt

                                                                                                                                                                                                                          func MinInt(i []int) interface{}

                                                                                                                                                                                                                            MinInt validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []int It returns int or nil It returns nil for the following cases:

                                                                                                                                                                                                                            - input is of length 0
                                                                                                                                                                                                                            

                                                                                                                                                                                                                            func MinInt16

                                                                                                                                                                                                                            func MinInt16(i []int16) interface{}

                                                                                                                                                                                                                              MinInt16 validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []int16 It returns int16 or nil It returns nil for the following cases:

                                                                                                                                                                                                                              - input is of length 0
                                                                                                                                                                                                                              

                                                                                                                                                                                                                              func MinInt32

                                                                                                                                                                                                                              func MinInt32(i []int32) interface{}

                                                                                                                                                                                                                                MinInt32 validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []int32 It returns int32 or nil It returns nil for the following cases:

                                                                                                                                                                                                                                - input is of length 0
                                                                                                                                                                                                                                

                                                                                                                                                                                                                                func MinInt64

                                                                                                                                                                                                                                func MinInt64(i []int64) interface{}

                                                                                                                                                                                                                                  MinInt64 validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []int64 It returns int64 or nil It returns nil for the following cases:

                                                                                                                                                                                                                                  - input is of length 0
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  func MinInt8

                                                                                                                                                                                                                                  func MinInt8(i []int8) interface{}

                                                                                                                                                                                                                                    MinInt8 validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []int8 It returns int8 or nil It returns nil for the following cases:

                                                                                                                                                                                                                                    - input is of length 0
                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                    func MinString

                                                                                                                                                                                                                                    func MinString(i []string) interface{}

                                                                                                                                                                                                                                      MinString validates the input, compares the elements and returns the minimum element in an array/slice. It accepts []string It returns string or nil It returns nil for the following cases:

                                                                                                                                                                                                                                      - input is of length 0
                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                      func NotEmpty

                                                                                                                                                                                                                                      func NotEmpty(obj interface{}) bool

                                                                                                                                                                                                                                        NotEmpty returns if the object is considered as non-empty or not.

                                                                                                                                                                                                                                        func NotEqual

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

                                                                                                                                                                                                                                          NotEqual returns if the two objects are not equal

                                                                                                                                                                                                                                          func OuterJoin

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

                                                                                                                                                                                                                                            OuterJoin finds and returns dissimilar data from two collections.

                                                                                                                                                                                                                                            func OuterJoinFloat32

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

                                                                                                                                                                                                                                              OuterJoinFloat32 finds and returns dissimilar data from two float32 collections.

                                                                                                                                                                                                                                              func OuterJoinFloat64

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

                                                                                                                                                                                                                                                OuterJoinFloat64 finds and returns dissimilar data from two float64 collections.

                                                                                                                                                                                                                                                func OuterJoinInt

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

                                                                                                                                                                                                                                                  OuterJoinInt finds and returns dissimilar data from two int collections.

                                                                                                                                                                                                                                                  func OuterJoinInt32

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

                                                                                                                                                                                                                                                    OuterJoinInt32 finds and returns dissimilar data from two int32 collections.

                                                                                                                                                                                                                                                    func OuterJoinInt64

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

                                                                                                                                                                                                                                                      OuterJoinInt64 finds and returns dissimilar data from two int64 collections.

                                                                                                                                                                                                                                                      func OuterJoinString

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

                                                                                                                                                                                                                                                        OuterJoinString finds and returns dissimilar data from two string collections.

                                                                                                                                                                                                                                                        func Product

                                                                                                                                                                                                                                                        func Product(arr interface{}) float64

                                                                                                                                                                                                                                                          Product computes the product of the values in array.

                                                                                                                                                                                                                                                          func PtrOf

                                                                                                                                                                                                                                                          func PtrOf(itf interface{}) interface{}

                                                                                                                                                                                                                                                            PtrOf makes a copy of the given interface and returns a pointer.

                                                                                                                                                                                                                                                            func RandomInt

                                                                                                                                                                                                                                                            func RandomInt(min, max int) int

                                                                                                                                                                                                                                                              RandomInt generates a random int, based on a min and max values

                                                                                                                                                                                                                                                              func RandomString

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

                                                                                                                                                                                                                                                                RandomString returns a random string with a fixed length

                                                                                                                                                                                                                                                                func Reduce

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

                                                                                                                                                                                                                                                                  Reduce takes a collection and reduces it to a single value using a reduction function (or a valid symbol) and an accumulator value.

                                                                                                                                                                                                                                                                  func Reverse

                                                                                                                                                                                                                                                                  func Reverse(in interface{}) interface{}

                                                                                                                                                                                                                                                                    Reverse transforms an array the first element will become the last, the second element will become the second to last, etc.

                                                                                                                                                                                                                                                                    func ReverseFloat32

                                                                                                                                                                                                                                                                    func ReverseFloat32(s []float32) []float32

                                                                                                                                                                                                                                                                      ReverseFloat32 reverses an array of float32

                                                                                                                                                                                                                                                                      func ReverseFloat64

                                                                                                                                                                                                                                                                      func ReverseFloat64(s []float64) []float64

                                                                                                                                                                                                                                                                        ReverseFloat64 reverses an array of float64

                                                                                                                                                                                                                                                                        func ReverseInt

                                                                                                                                                                                                                                                                        func ReverseInt(s []int) []int

                                                                                                                                                                                                                                                                          ReverseInt reverses an array of int

                                                                                                                                                                                                                                                                          func ReverseInt32

                                                                                                                                                                                                                                                                          func ReverseInt32(s []int32) []int32

                                                                                                                                                                                                                                                                            ReverseInt32 reverses an array of int32

                                                                                                                                                                                                                                                                            func ReverseInt64

                                                                                                                                                                                                                                                                            func ReverseInt64(s []int64) []int64

                                                                                                                                                                                                                                                                              ReverseInt64 reverses an array of int64

                                                                                                                                                                                                                                                                              func ReverseString

                                                                                                                                                                                                                                                                              func ReverseString(s string) string

                                                                                                                                                                                                                                                                                ReverseString reverses a string

                                                                                                                                                                                                                                                                                func ReverseStrings

                                                                                                                                                                                                                                                                                func ReverseStrings(s []string) []string

                                                                                                                                                                                                                                                                                  ReverseStrings reverses an array of string

                                                                                                                                                                                                                                                                                  func RightJoin

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

                                                                                                                                                                                                                                                                                    LeftJoin finds and returns dissimilar data from the second collection (right).

                                                                                                                                                                                                                                                                                    func RightJoinFloat32

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

                                                                                                                                                                                                                                                                                      LeftJoinFloat32 finds and returns dissimilar data from the second float32 collection (right).

                                                                                                                                                                                                                                                                                      func RightJoinFloat64

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

                                                                                                                                                                                                                                                                                        LeftJoinFloat64 finds and returns dissimilar data from the second float64 collection (right).

                                                                                                                                                                                                                                                                                        func RightJoinInt

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

                                                                                                                                                                                                                                                                                          LeftJoinInt finds and returns dissimilar data from the second int collection (right).

                                                                                                                                                                                                                                                                                          func RightJoinInt32

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

                                                                                                                                                                                                                                                                                            LeftJoinInt32 finds and returns dissimilar data from the second int32 collection (right).

                                                                                                                                                                                                                                                                                            func RightJoinInt64

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

                                                                                                                                                                                                                                                                                              LeftJoinInt64 finds and returns dissimilar data from the second int64 collection (right).

                                                                                                                                                                                                                                                                                              func RightJoinString

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

                                                                                                                                                                                                                                                                                                LeftJoinString finds and returns dissimilar data from the second string collection (right).

                                                                                                                                                                                                                                                                                                func Shard

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

                                                                                                                                                                                                                                                                                                  Shard will shard a string name

                                                                                                                                                                                                                                                                                                  func Shuffle

                                                                                                                                                                                                                                                                                                  func Shuffle(in interface{}) interface{}

                                                                                                                                                                                                                                                                                                    Shuffle creates an array of shuffled values

                                                                                                                                                                                                                                                                                                    func ShuffleFloat32

                                                                                                                                                                                                                                                                                                    func ShuffleFloat32(a []float32) []float32

                                                                                                                                                                                                                                                                                                      ShuffleFloat32 creates an array of float32 shuffled values using Fisher–Yates algorithm

                                                                                                                                                                                                                                                                                                      func ShuffleFloat64

                                                                                                                                                                                                                                                                                                      func ShuffleFloat64(a []float64) []float64

                                                                                                                                                                                                                                                                                                        ShuffleFloat64 creates an array of float64 shuffled values using Fisher–Yates algorithm

                                                                                                                                                                                                                                                                                                        func ShuffleInt

                                                                                                                                                                                                                                                                                                        func ShuffleInt(a []int) []int

                                                                                                                                                                                                                                                                                                          ShuffleInt creates an array of int shuffled values using Fisher–Yates algorithm

                                                                                                                                                                                                                                                                                                          func ShuffleInt32

                                                                                                                                                                                                                                                                                                          func ShuffleInt32(a []int32) []int32

                                                                                                                                                                                                                                                                                                            ShuffleInt32 creates an array of int32 shuffled values using Fisher–Yates algorithm

                                                                                                                                                                                                                                                                                                            func ShuffleInt64

                                                                                                                                                                                                                                                                                                            func ShuffleInt64(a []int64) []int64

                                                                                                                                                                                                                                                                                                              ShuffleInt64 creates an array of int64 shuffled values using Fisher–Yates algorithm

                                                                                                                                                                                                                                                                                                              func ShuffleString

                                                                                                                                                                                                                                                                                                              func ShuffleString(a []string) []string

                                                                                                                                                                                                                                                                                                                ShuffleString creates an array of string shuffled values using Fisher–Yates algorithm

                                                                                                                                                                                                                                                                                                                func SliceOf

                                                                                                                                                                                                                                                                                                                func SliceOf(in interface{}) interface{}

                                                                                                                                                                                                                                                                                                                  SliceOf returns a slice which contains the element.

                                                                                                                                                                                                                                                                                                                  func Some

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

                                                                                                                                                                                                                                                                                                                    Some returns true if atleast one element is present in an iteratee.

                                                                                                                                                                                                                                                                                                                    Example
                                                                                                                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    true
                                                                                                                                                                                                                                                                                                                    false
                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                    func Subset

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

                                                                                                                                                                                                                                                                                                                      Subset returns true if collection x is a subset of y.

                                                                                                                                                                                                                                                                                                                      func Subtract

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

                                                                                                                                                                                                                                                                                                                        Subtract returns the subtraction between two collections.

                                                                                                                                                                                                                                                                                                                        func SubtractString

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

                                                                                                                                                                                                                                                                                                                          SubtractString returns the subtraction between two collections of string

                                                                                                                                                                                                                                                                                                                          func Sum

                                                                                                                                                                                                                                                                                                                          func Sum(arr interface{}) float64

                                                                                                                                                                                                                                                                                                                            Sum computes the sum of the values in array.

                                                                                                                                                                                                                                                                                                                            func SumFloat32

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

                                                                                                                                                                                                                                                                                                                              SumFloat32 sums a float32 iteratee and returns the sum of all elements

                                                                                                                                                                                                                                                                                                                              func SumFloat64

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

                                                                                                                                                                                                                                                                                                                                SumFloat64 sums a float64 iteratee and returns the sum of all elements

                                                                                                                                                                                                                                                                                                                                func SumInt

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

                                                                                                                                                                                                                                                                                                                                  SumInt sums a int iteratee and returns the sum of all elements

                                                                                                                                                                                                                                                                                                                                  func SumInt32

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

                                                                                                                                                                                                                                                                                                                                    SumInt32 sums a int32 iteratee and returns the sum of all elements

                                                                                                                                                                                                                                                                                                                                    func SumInt64

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

                                                                                                                                                                                                                                                                                                                                      SumInt64 sums a int64 iteratee and returns the sum of all elements

                                                                                                                                                                                                                                                                                                                                      func Tail

                                                                                                                                                                                                                                                                                                                                      func Tail(arr interface{}) interface{}

                                                                                                                                                                                                                                                                                                                                        Tail gets all but the first element of array.

                                                                                                                                                                                                                                                                                                                                        func ToFloat64

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

                                                                                                                                                                                                                                                                                                                                          ToFloat64 converts any numeric value to float64.

                                                                                                                                                                                                                                                                                                                                          func ToMap

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

                                                                                                                                                                                                                                                                                                                                            ToMap transforms a slice of instances to a Map. []*Foo => Map<int, *Foo>

                                                                                                                                                                                                                                                                                                                                            func Uniq

                                                                                                                                                                                                                                                                                                                                            func Uniq(in interface{}) interface{}

                                                                                                                                                                                                                                                                                                                                              Uniq creates an array with unique values.

                                                                                                                                                                                                                                                                                                                                              func UniqFloat32

                                                                                                                                                                                                                                                                                                                                              func UniqFloat32(a []float32) []float32

                                                                                                                                                                                                                                                                                                                                                UniqFloat32 creates an array of float32 with unique values.

                                                                                                                                                                                                                                                                                                                                                func UniqFloat64

                                                                                                                                                                                                                                                                                                                                                func UniqFloat64(a []float64) []float64

                                                                                                                                                                                                                                                                                                                                                  UniqFloat64 creates an array of float64 with unique values.

                                                                                                                                                                                                                                                                                                                                                  func UniqInt

                                                                                                                                                                                                                                                                                                                                                  func UniqInt(a []int) []int

                                                                                                                                                                                                                                                                                                                                                    UniqInt creates an array of int with unique values.

                                                                                                                                                                                                                                                                                                                                                    func UniqInt32

                                                                                                                                                                                                                                                                                                                                                    func UniqInt32(a []int32) []int32

                                                                                                                                                                                                                                                                                                                                                      UniqInt32 creates an array of int32 with unique values.

                                                                                                                                                                                                                                                                                                                                                      func UniqInt64

                                                                                                                                                                                                                                                                                                                                                      func UniqInt64(a []int64) []int64

                                                                                                                                                                                                                                                                                                                                                        UniqInt64 creates an array of int64 with unique values.

                                                                                                                                                                                                                                                                                                                                                        func UniqString

                                                                                                                                                                                                                                                                                                                                                        func UniqString(a []string) []string

                                                                                                                                                                                                                                                                                                                                                          UniqString creates an array of string with unique values.

                                                                                                                                                                                                                                                                                                                                                          func Values

                                                                                                                                                                                                                                                                                                                                                          func Values(out interface{}) interface{}

                                                                                                                                                                                                                                                                                                                                                            Values creates an array of the own enumerable map values or struct field values.

                                                                                                                                                                                                                                                                                                                                                            func Without

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

                                                                                                                                                                                                                                                                                                                                                              Without creates an array excluding all given values.

                                                                                                                                                                                                                                                                                                                                                              func ZeroOf

                                                                                                                                                                                                                                                                                                                                                              func ZeroOf(in interface{}) interface{}

                                                                                                                                                                                                                                                                                                                                                                ZeroOf returns a zero value of an element.

                                                                                                                                                                                                                                                                                                                                                                Types

                                                                                                                                                                                                                                                                                                                                                                type Builder

                                                                                                                                                                                                                                                                                                                                                                type Builder interface {
                                                                                                                                                                                                                                                                                                                                                                	Chunk(size int) Builder
                                                                                                                                                                                                                                                                                                                                                                	Compact() Builder
                                                                                                                                                                                                                                                                                                                                                                	Drop(n int) Builder
                                                                                                                                                                                                                                                                                                                                                                	Filter(predicate interface{}) Builder
                                                                                                                                                                                                                                                                                                                                                                	FlattenDeep() Builder
                                                                                                                                                                                                                                                                                                                                                                	Initial() Builder
                                                                                                                                                                                                                                                                                                                                                                	Intersect(y interface{}) Builder
                                                                                                                                                                                                                                                                                                                                                                	Join(rarr interface{}, fnc JoinFnc) Builder
                                                                                                                                                                                                                                                                                                                                                                	Map(mapFunc interface{}) Builder
                                                                                                                                                                                                                                                                                                                                                                	Reverse() Builder
                                                                                                                                                                                                                                                                                                                                                                	Shuffle() Builder
                                                                                                                                                                                                                                                                                                                                                                	Tail() Builder
                                                                                                                                                                                                                                                                                                                                                                	Uniq() Builder
                                                                                                                                                                                                                                                                                                                                                                	Without(values ...interface{}) Builder
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	All() bool
                                                                                                                                                                                                                                                                                                                                                                	Any() bool
                                                                                                                                                                                                                                                                                                                                                                	Contains(elem interface{}) bool
                                                                                                                                                                                                                                                                                                                                                                	Every(elements ...interface{}) bool
                                                                                                                                                                                                                                                                                                                                                                	Find(predicate interface{}) interface{}
                                                                                                                                                                                                                                                                                                                                                                	ForEach(predicate interface{})
                                                                                                                                                                                                                                                                                                                                                                	ForEachRight(predicate interface{})
                                                                                                                                                                                                                                                                                                                                                                	Head() interface{}
                                                                                                                                                                                                                                                                                                                                                                	Keys() interface{}
                                                                                                                                                                                                                                                                                                                                                                	IndexOf(elem interface{}) int
                                                                                                                                                                                                                                                                                                                                                                	IsEmpty() bool
                                                                                                                                                                                                                                                                                                                                                                	Last() interface{}
                                                                                                                                                                                                                                                                                                                                                                	LastIndexOf(elem interface{}) int
                                                                                                                                                                                                                                                                                                                                                                	NotEmpty() bool
                                                                                                                                                                                                                                                                                                                                                                	Product() float64
                                                                                                                                                                                                                                                                                                                                                                	Reduce(reduceFunc, acc interface{}) float64
                                                                                                                                                                                                                                                                                                                                                                	Sum() float64
                                                                                                                                                                                                                                                                                                                                                                	Type() reflect.Type
                                                                                                                                                                                                                                                                                                                                                                	Value() interface{}
                                                                                                                                                                                                                                                                                                                                                                	Values() interface{}
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  Builder contains all tools which can be chained.

                                                                                                                                                                                                                                                                                                                                                                  func Chain

                                                                                                                                                                                                                                                                                                                                                                  func Chain(v interface{}) Builder

                                                                                                                                                                                                                                                                                                                                                                    Chain creates a simple new go-funk.Builder from a collection. Each method call generate a new builder containing the previous result.

                                                                                                                                                                                                                                                                                                                                                                    Example
                                                                                                                                                                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                    func LazyChain

                                                                                                                                                                                                                                                                                                                                                                    func LazyChain(v interface{}) Builder

                                                                                                                                                                                                                                                                                                                                                                      LazyChain creates a lazy go-funk.Builder from a collection. Each method call generate a new builder containing a method generating the previous value. With that, all data are only generated when we call a tailling method like All or Find.

                                                                                                                                                                                                                                                                                                                                                                      Example
                                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                      func LazyChainWith

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

                                                                                                                                                                                                                                                                                                                                                                        LazyChainWith creates a lzy go-funk.Builder from a generator. Like LazyChain, each method call generate a new builder containing a method generating the previous value. But, instead of using a collection, it takes a generator which can generate values. With LazyChainWith, to can create a generic pipeline of collection transformation and, throw the generator, sending different collection.

                                                                                                                                                                                                                                                                                                                                                                        type JoinFloat32Fnc

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

                                                                                                                                                                                                                                                                                                                                                                        type JoinFloat64Fnc

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

                                                                                                                                                                                                                                                                                                                                                                        type JoinFnc

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

                                                                                                                                                                                                                                                                                                                                                                        type JoinInt32Fnc

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

                                                                                                                                                                                                                                                                                                                                                                        type JoinInt64Fnc

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

                                                                                                                                                                                                                                                                                                                                                                        type JoinIntFnc

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

                                                                                                                                                                                                                                                                                                                                                                        type JoinStringFnc

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

                                                                                                                                                                                                                                                                                                                                                                        type Tuple

                                                                                                                                                                                                                                                                                                                                                                        type Tuple struct {
                                                                                                                                                                                                                                                                                                                                                                        	Element1 interface{}
                                                                                                                                                                                                                                                                                                                                                                        	Element2 interface{}
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          Tuple is the return type of Zip

                                                                                                                                                                                                                                                                                                                                                                          func Zip

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

                                                                                                                                                                                                                                                                                                                                                                            Zip returns a list of tuples, where the i-th tuple contains the i-th element from each of the input iterables. The returned list is truncated in length to the length of the shortest input iterable.