funk

package module
v0.0.0-...-54489e5 Latest Latest
Warning

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

 Go to latest Published: Jan 10, 2018 License: MIT Imports: 7 Imported by: 9

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 looks like lodash_ in some aspects but
it will have its own roadmap, lodash_ is an awesome library with a lot of works 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 types, 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.IndexOf
............

Gets the index at which the first occurrence of value is found in 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 value is found in 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.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 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.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.Sum
........

Computes the sum of the values in 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 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"}

Performance
-----------

``go-funk`` has currently 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 uses 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>`_
* 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

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

Documentation

Index

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

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

Map manipulates an iteratee and transforms it to another type.

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

func ZeroOf(in interface{}) interface{}

ZeroOf returns a zero value of an element.

Types

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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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