pie

func Abs ¶

func Abs[T constraints.Integer | constraints.Float](val T) T

Abs returns the absolute value.

func All ¶

func All[T any](ss []T, fn func(value T) bool) bool

All will return true if all callbacks return true. It follows the same logic as the all() function in Python.

If the list is empty then true is always returned.

func Any ¶

func Any[T any](ss []T, fn func(value T) bool) bool

Any will return true if any callbacks return true. It follows the same logic as the any() function in Python.

If the list is empty then false is always returned.

func AreSorted ¶

func AreSorted[T constraints.Ordered](ss []T) bool

AreSorted will return true if the slice is already sorted. It is a wrapper for sort.SliceIsSorted.

func AreUnique ¶

func AreUnique[T comparable](ss []T) bool

AreUnique will return true if the slice contains elements that are all different (unique) from each other.

func Average ¶

func Average[T constraints.Integer | constraints.Float](ss []T) float64

Average is the average of all of the elements, or zero if there are no elements.

func Bottom ¶

func Bottom[T any](ss []T, n int) (top []T)

Bottom will return n elements from bottom

that means that elements is taken from the end of the slice for this [1,2,3] slice with n == 2 will be returned [3,2] if the slice has less elements then n that'll return all elements if n < 0 it'll return empty slice.

func Chunk ¶ added in v2.3.0

func Chunk[T any](ss []T, chunkLength int) [][]T

Chunk splits the input and returns multi slices whose length equals chunkLength, except for the last slice which may contain fewer elements.

Examples:

Chunk([1, 2, 3], 4) => [ [1, 2, 3] ]
Chunk([1, 2, 3], 3) => [ [1, 2, 3] ]
Chunk([1, 2, 3], 2) => [ [1, 2], [3] ]
Chunk([1, 2, 3], 1) => [ [1], [2], [3] ]
Chunk([], 1)        => [ [] ]
Chunk([1, 2, 3], 0) => panic: chunkLength should be greater than 0

func Contains ¶

func Contains[T comparable](ss []T, lookingFor T) bool

Contains returns true if the element exists in the slice.

When using slices of pointers it will only compare by address, not value.

func Delete ¶ added in v2.7.0

func Delete[T any](ss []T, idx ...int) []T

Removes elements at indices in idx from input slice, returns resulting slice. If an index is out of bounds, skip it.

func Diff ¶

func Diff[T comparable](ss []T, against []T) (added, removed []T)

Diff returns the elements that needs to be added or removed from the first slice to have the same elements in the second slice.

The order of elements is not taken into consideration, so the slices are treated sets that allow duplicate items.

The added and removed returned may be blank respectively, or contain upto as many elements that exists in the largest slice.

func DropTop ¶

func DropTop[T any](ss []T, n int) (drop []T)

DropTop will return the rest slice after dropping the top n elements if the slice has less elements then n that'll return empty slice if n < 0 it'll return empty slice.

func DropWhile ¶

func DropWhile[T comparable](ss []T, f func(s T) bool) (ss2 []T)

Drop items from the slice while f(item) is true. Afterwards, return every element until the slice is empty. It follows the same logic as the dropwhile() function from itertools in Python.

func Each ¶

func Each[T any](ss []T, fn func(T)) []T

Each is more condensed version of Transform that allows an action to happen on each elements and pass the original slice on.

pie.Each(cars, func (car *Car) {
    fmt.Printf("Car color is: %s\n", car.Color)
})

Pie will not ensure immutability on items passed in so they can be manipulated, if you choose to do it this way, for example:

// Set all car colors to Red.
pie.Each(cars, func (car *Car) {
    car.Color = "Red"
})

func Equals ¶

func Equals[T comparable](ss []T, rhs []T) bool

Equals compare elements from the start to the end,

if they are the same is considered the slices are equal if all elements are the same is considered the slices are equal if each slice == nil is considered that they're equal

if element realizes Equals interface it uses that method, in other way uses default compare

func Filter ¶

func Filter[T any](ss []T, condition func(T) bool) (ss2 []T)

Filter will return a new slice containing only the elements that return true from the condition. The returned slice may contain zero elements (nil).

FilterNot works in the opposite way of Filter.

func FilterNot ¶

func FilterNot[T any](ss []T, condition func(T) bool) (ss2 []T)

FilterNot works the same as Filter, with a negated condition. That is, it will return a new slice only containing the elements that returned false from the condition. The returned slice may contain zero elements (nil).

func FindFirstUsing ¶

func FindFirstUsing[T any](ss []T, fn func(value T) bool) int

FindFirstUsing will return the index of the first element when the callback returns true or -1 if no element is found. It follows the same logic as the findIndex() function in Javascript.

If the list is empty then -1 is always returned.

func First ¶ added in v2.1.0

func First[T any](ss []T) T

First returns the first element or a zero value if there are no elements.

func FirstOr ¶

func FirstOr[T any](ss []T, defaultValue T) T

FirstOr returns the first element or a default value if there are no elements.

func Flat ¶ added in v2.4.0

func Flat[T any](ss [][]T) (ss2 []T)

Flat flattens the two-dimensional slice into one-dimensional slice. Slices of zero-length are ignored.

Examples:

Flat([[100], [101, 102], [102, 103]])   => [100, 101, 102, 102, 103]
Flat([nil, [101, 102], []])             => [101, 102]

func Float64 ¶

func Float64[T constraints.Ordered](x T) float64

Float64 transforms a value into a float64. This should only be used on slices that resolve to strings that represent numbers. An invalid value will use zero.

func Float64s ¶

func Float64s[T constraints.Ordered](ss []T) []float64

Float64s transforms each element to a float64.

func Group ¶

func Group[T comparable](ss []T) map[T]int

Group returns a map of the value with an individual count.

func GroupBy ¶ added in v2.5.0

func GroupBy[T comparable, U any](values []U, getKey func(U) T) map[T][]U

GroupBy groups slice elements by key returned by getKey function for each slice element.

It returns a map in which slices of elements of original slice are matched to keys defined by getKey function. It returns non-nil map, if empty or nil slice is passed.

For example, if you want to group integers by their remainder from division by 5, you can use this function as follows:

_ = pie.GroupBy(
    []int{23, 76, 37, 11, 23, 47},
    func(num int) int {
        return num % 5
    },
)

In above case map {1:[76, 11], 2:[37, 47], 3:[23, 23]} is returned.

func Insert ¶

func Insert[T any](ss []T, index int, values ...T) []T

Insert a value at an index.

func Int ¶

func Int[T constraints.Ordered](x T) int

Int transforms a value into an int. This should only be used on slices that resolve to strings that represent numbers. An invalid value will use zero and fractional values will be truncated.

func Intersect ¶

func Intersect[T comparable](ss []T, slices ...[]T) (ss2 []T)

Intersect returns items that exist in all lists.

It returns slice without any duplicates. If zero slice arguments are provided, then nil is returned.

func Ints ¶

func Ints[T constraints.Ordered](ss []T) []int

Ints transforms each element to an integer.

func JSONBytes ¶

func JSONBytes[T constraints.Ordered](ss []T) []byte

JSONBytes returns the JSON encoded array as bytes.

One important thing to note is that it will treat a nil slice as an empty slice to ensure that the JSON value return is always an array.

func JSONBytesIndent ¶

func JSONBytesIndent[T constraints.Ordered](ss []T, prefix, indent string) []byte

JSONBytesIndent returns the JSON encoded array as bytes with indent applied.

One important thing to note is that it will treat a nil slice as an empty slice to ensure that the JSON value return is always an array. See json.MarshalIndent for details.

func JSONString ¶

func JSONString[T constraints.Ordered](ss []T) string

JSONString returns the JSON encoded array as a string.

One important thing to note is that it will treat a nil slice as an empty slice to ensure that the JSON value return is always an array.

func JSONStringIndent ¶

func JSONStringIndent[T constraints.Ordered](ss []T, prefix, indent string) string

JSONStringIndent returns the JSON encoded array as a string with indent applied.

One important thing to note is that it will treat a nil slice as an empty slice to ensure that the JSON value return is always an array. See json.MarshalIndent for details.

func Join ¶

func Join[T constraints.Ordered](ss []T, glue string) (s string)

Join returns a string from joining each of the elements.

func Keys ¶

func Keys[K comparable, V any](m map[K]V) []K

Keys returns the keys in the map. All of the items will be unique.

Due to Go's randomization of iterating maps the order is not deterministic.

func Last ¶ added in v2.1.0

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

Last returns the last element or a zero value if there are no elements.

func LastOr ¶

func LastOr[T any](ss []T, defaultValue T) T

LastOr returns the last element or a default value if there are no elements.

func Map ¶

func Map[T any, U any](ss []T, fn func(T) U) (ss2 []U)

Map will return a new slice where each element has been mapped (transformed). The number of elements returned will always be the same as the input.

Be careful when using this with slices of pointers. If you modify the input value it will affect the original slice. Be sure to return a new allocated object or deep copy the existing one.

func Max ¶

func Max[T constraints.Ordered](ss []T) (max T)

Max is the maximum value, or zero.

func Median ¶

func Median[T constraints.Integer | constraints.Float](ss []T) T

Median returns the value separating the higher half from the lower half of a data sample.

Zero is returned if there are no elements in the slice.

If the number of elements is even, then the ElementType mean of the two "median values" is returned.

func Min ¶

func Min[T constraints.Ordered](ss []T) (min T)

Min is the minimum value, or zero.

func Mode ¶

func Mode[T comparable](ss []T) []T

Mode returns a new slice containing the most frequently occuring values.

The number of items returned may be the same as the input or less. It will never return zero items unless the input slice has zero items.

func Pop ¶

func Pop[T any](ss *[]T) (popped *T)

Pop the first element of the slice

Usage Example:

type knownGreetings []string
greetings := knownGreetings{"ciao", "hello", "hola"}
for greeting := greetings.Pop(); greeting != nil; greeting = greetings.Pop() {
    fmt.Println(*greeting)
}

func Product ¶

func Product[T constraints.Integer | constraints.Float](ss []T) (product T)

Product is the product of all of the elements.

func Random ¶

func Random[T constraints.Integer | constraints.Float](ss []T, source rand.Source) T

Random returns a random element by your rand.Source, or zero.

func Reduce ¶

func Reduce[T any](ss []T, reducer func(T, T) T) (el T)

Reduce continually applies the provided function over the slice. Reducing the elements to a single value.

Returns a zero value of T if there are no elements in the slice. It will panic if the reducer is nil and the slice has more than one element (required to invoke reduce). Otherwise returns result of applying reducer from left to right.

func Reverse ¶

func Reverse[T any](ss []T) []T

Reverse returns a new copy of the slice with the elements ordered in reverse. This is useful when combined with Sort to get a descending sort order:

ss.Sort().Reverse()

func Rotate ¶ added in v2.8.0

func Rotate[T any](ss []T, n int) []T

Rotate return slice circularly rotated by a number of positions n. If n is positive, the slice is rotated right. If n is negative, the slice is rotated left.

func Send ¶

func Send[T any](ctx context.Context, ss []T, ch chan<- T) []T

Send sends elements to channel in normal act it sends all elements but if func canceled it can be less

it locks execution of gorutine it doesn't close channel after work returns sent elements if len(this) != len(old) considered func was canceled

func Sequence ¶

func Sequence[T constraints.Integer | constraints.Float](ss []T, params ...int) []T

Sequence generates all numbers in range or returns nil if params invalid

There are 3 variations to generate:

1. [0, n).
2. [min, max).
3. [min, max) with step.

if len(params) == 1 considered that will be returned slice between 0 and n, where n is the first param, [0, n). if len(params) == 2 considered that will be returned slice between min and max, where min is the first param, max is the second, [min, max). if len(params) > 2 considered that will be returned slice between min and max with step, where min is the first param, max is the second, step is the third one, [min, max) with step, others params will be ignored

func SequenceUsing ¶

func SequenceUsing[T any](ss []T, creator func(int) T, params ...int) []T

SequenceUsing generates slice in range using creator function

There are 3 variations to generate:

1. [0, n).
2. [min, max).
3. [min, max) with step.

if len(params) == 1 considered that will be returned slice between 0 and n, where n is the first param, [0, n). if len(params) == 2 considered that will be returned slice between min and max, where min is the first param, max is the second, [min, max). if len(params) > 2 considered that will be returned slice between min and max with step, where min is the first param, max is the second, step is the third one, [min, max) with step, others params will be ignored

func Shift ¶

func Shift[T any](ss []T) (T, []T)

Shift will return two values: the shifted value and the rest slice. if the slice is empty then returned shifted value is the zero value of the slice elements and the rest slice is empty slice

func Shuffle ¶

func Shuffle[T any](ss []T, source rand.Source) []T

Shuffle returns a new shuffled slice by your rand.Source. The original slice is not modified.

func Sort ¶

func Sort[T constraints.Ordered](ss []T) []T

Sort works similar to sort.SliceType(). However, unlike sort.SliceType the slice returned will be reallocated as to not modify the input slice.

See Reverse() and AreSorted().

func SortStableUsing ¶

func SortStableUsing[T comparable](ss []T, less func(a, b T) bool) []T

SortStableUsing works similar to sort.SliceStable. However, unlike sort.SliceStable the slice returned will be reallocated as to not modify the input slice.

func SortUsing ¶

func SortUsing[T any](ss []T, less func(a, b T) bool) []T

SortUsing works similar to sort.Slice. However, unlike sort.Slice the slice returned will be reallocated as to not modify the input slice.

func Stddev ¶

func Stddev[T constraints.Integer | constraints.Float](ss []T) float64

Stddev is the standard deviation

func String ¶

func String[T constraints.Ordered](s T) string

String transforms a value into a string. Nil values will be treated as empty strings.

If the element type implements fmt.Stringer it will be used. Otherwise it will fallback to the result of:

fmt.Sprintf("%v")

func Strings ¶

func Strings[T constraints.Ordered](ss []T) []string

Strings transforms each element to a string.

If the element type implements fmt.Stringer it will be used. Otherwise it will fallback to the result of:

fmt.Sprintf("%v")

func StringsUsing ¶

func StringsUsing[T any](ss []T, transform func(T) string) []string

StringsUsing transforms each element to a string.

func SubSlice ¶

func SubSlice[T any](ss []T, start int, end int) (subSlice []T)

SubSlice will return the subSlice from start to end(excluded)

Condition 1: If start < 0 or end < 0, nil is returned. Condition 2: If start >= end, nil is returned. Condition 3: Return all elements that exist in the range provided, if start or end is out of bounds, zero items will be placed.

func Sum ¶

func Sum[T constraints.Integer | constraints.Float](ss []T) (sum T)

Sum is the sum of all of the elements.

func Top ¶

func Top[T any](ss []T, n int) (top []T)

Top will return n elements from head of the slice if the slice has less elements then n that'll return all elements if n < 0 it'll return empty slice.

func Unique ¶

func Unique[T comparable](ss []T) []T

Unique returns a new slice with all of the unique values.

The items will be returned in a randomized order, even with the same input.

The number of items returned may be the same as the input or less. It will never return zero items unless then input slice has zero items.

A slice with zero elements is considered to be unique.

See AreUnique().

func Unshift ¶

func Unshift[T any](ss []T, elements ...T) (unshift []T)

Unshift adds one or more elements to the beginning of the slice and returns the new slice.

func Values ¶

func Values[K comparable, V any](m map[K]V) []V

Values returns the values in the map.

Due to Go's randomization of iterating maps the order is not deterministic.