just

README

just

This project is contains functions that help to do noizy things in every project.

• Filter slices, maps.
• Apply functions to collections.
• Null[any] for optional fields in api an sql.DB requests.

Documentation

Index

• func Abs[T number](v T) T
• func Bool[T builtin](v T) bool
• func MapContainsKey[K comparable, V any](m map[K]V, key K) bool
• func MapContainsKeysAll[K comparable, V any](m map[K]V, keys []K) bool
• func MapContainsKeysAny[K comparable, V any](m map[K]V, keys []K) bool
• func MapCopy[K comparable, V any](m map[K]V) map[K]V
• func MapDefaults[K comparable, V any](m map[K]V, defaults map[K]V) map[K]V
• func MapFilter[K comparable, V any](in map[K]V, fn func(k K, v V) bool) map[K]V
• func MapFilterKeys[K comparable, V any](in map[K]V, fn func(k K) bool) map[K]V
• func MapFilterValues[K comparable, V any](in map[K]V, fn func(v V) bool) map[K]V
• func MapGetKeys[K comparable, V any](m map[K]V) []K
• func MapGetValues[K comparable, V any](m map[K]V) []V
• func MapMap[K, K1 comparable, V, V1 any](in map[K]V, fn func(K, V) (K1, V1)) map[K1]V1
• func MapMerge[K comparable, V any](m1, m2 map[K]V, fn func(k K, v1, v2 V) V) map[K]V
• func Max[T number](in ...T) T
• func MaxDefault[T number](in ...T) T
• func MaxOr[T number](defaultVal T, in ...T) T
• func Min[T number](in ...T) T
• func MinDefault[T number](in ...T) T
• func MinOr[T number](defaultVal T, in ...T) T
• func Pointer[T any](v T) *T
• func Slice2Map[T comparable](in []T) map[T]struct{}
• func SliceAddNotExists[T comparable](in []T, elem T) []T
• func SliceAll[T any](in []T, fn func(T) bool) bool
• func SliceAny[T any](in []T, fn func(T) bool) bool
• func SliceApply[T any](in []T, fn func(int, T))
• func SliceChain[T any](in ...[]T) []T
• func SliceChunk[T any](in []T, fn func(i int, elem T) bool) [][]T
• func SliceChunkEvery[T any](in []T, every int) [][]T
• func SliceContainsElem[T comparable](in []T, elem T) bool
• func SliceDifference[T comparable](oldSlice, newSlice []T) []T
• func SliceEqualUnordered[T comparable](in1, in2 []T) bool
• func SliceFillElem[T any](l int, elem T) []T
• func SliceFilter[T any](in []T, fn func(T) bool) []T
• func SliceFindAllElements[T any](in []T, fn func(i int, elem T) bool) []T
• func SliceFindAllIndexes[T any](in []T, fn func(i int, elem T) bool) []int
• func SliceGroupBy[K comparable, V any](in []V, fn func(V) K) map[K][]V
• func SliceIntersection[T comparable](oldSlice, newSlice []T) []T
• func SliceMap[T any, V any](in []T, fn func(T) V) []V
• func SliceMapErr[T any, V any](in []T, fn func(T) (V, error)) ([]V, error)
• func SliceRange[T number](start, stop, step T) []T
• func SliceReverse[T any](in []T) []T
• func SliceSort[T any](in []T, less func(a, b T) bool)
• func SliceSortCopy[T any](in []T, less func(a, b T) bool) []T
• func SliceUnion[T comparable](in ...[]T) []T
• func SliceUniq[T comparable](in []T) []T
• func SliceWithout[T any](in []T, fn func(T) bool) []T
• func SliceWithoutElem[T comparable](in []T, elem T) []T
• func SliceZip[T any](in ...[]T) [][]T
• func Sum[T number](in ...T) T
• type KV
  • func MapPairs[K comparable, V any](m map[K]V) []KV[K, V]
• type NullVal
  • func Null[T any](val T) NullVal[T]
  • func NullNull[T any]() NullVal[T]
  • func (nv *NullVal[T]) Scan(value any) error
  • func (nv *NullVal[T]) SetDefault(val T) bool
  • func (nv NullVal[T]) Value() (driver.Value, error)
  • func (nv NullVal[T]) ValueOk() (T, bool)
• type SliceElem
  • func SliceFindAll[T any](in []T, fn func(i int, elem T) bool) []SliceElem[T]
  • func SliceFindFirst[T any](in []T, fn func(i int, elem T) bool) SliceElem[T]
  • func SliceFindFirstElem[T comparable](in []T, elem T) SliceElem[T]
  • func SliceFindLast[T any](in []T, fn func(i int, elem T) bool) SliceElem[T]
  • func SliceFindLastElem[T comparable](in []T, elem T) SliceElem[T]
  • func (e SliceElem[T]) Ok() bool
  • func (e SliceElem[T]) ValueIdx() (T, int)
  • func (e SliceElem[T]) ValueOk() (T, bool)

Functions

func Abs

func Abs[T number](v T) T

Abs returns abs value of v.

func Bool

func Bool[T builtin](v T) bool

Bool returns true if element not equal to default value for this type.

func MapContainsKey

func MapContainsKey[K comparable, V any](m map[K]V, key K) bool

MapContainsKey returns true if key is exists in the map.

func MapContainsKeysAll

func MapContainsKeysAll[K comparable, V any](m map[K]V, keys []K) bool

MapContainsKeysAll returns true when at all keys exists in the map.

func MapContainsKeysAny

func MapContainsKeysAny[K comparable, V any](m map[K]V, keys []K) bool

MapContainsKeysAny returns true when at least one key exists in the map.

func MapCopy

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

MapCopy returns a shallow copy of map.

func MapDefaults

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

MapDefaults returns the map `m` after filling in its non-exists keys by `defaults`. Example: {1:1}, {1:0, 2:2} => {1:1, 2:2}

func MapFilter

func MapFilter[K comparable, V any](in map[K]V, fn func(k K, v V) bool) map[K]V

MapFilter returns the map which contains elements that `fn(key, value) == true`.

func MapFilterKeys

func MapFilterKeys[K comparable, V any](in map[K]V, fn func(k K) bool) map[K]V

MapFilterKeys returns the map which contains elements that `fn(key) == true`. That is a simplified version of MapFilter.

func MapFilterValues

func MapFilterValues[K comparable, V any](in map[K]V, fn func(v V) bool) map[K]V

MapFilterValues returns the map which contains elements that `fn(value) == true`. That is a simplified version of MapFilter.

func MapGetKeys

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

MapGetKeys returns all keys of map.

func MapGetValues

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

MapGetValues returns all values of map. Not Uniq, unordered.

func MapMap

func MapMap[K, K1 comparable, V, V1 any](in map[K]V, fn func(K, V) (K1, V1)) map[K1]V1

MapMap apply fn to all kv pairs from in.

func MapMerge

func MapMerge[K comparable, V any](m1, m2 map[K]V, fn func(k K, v1, v2 V) V) map[K]V

MapMerge returns the map which contains all keys from m1, m2 and values from `fn(key, m1Value, m2Value)`.

func Max

func Max[T number](in ...T) T

Max returns the max number from `in`.

func MaxDefault

func MaxDefault[T number](in ...T) T

MaxDefault returns max element from `in` or default value for specified type when `in` is empty.

func MaxOr

func MaxOr[T number](defaultVal T, in ...T) T

MaxOr returns max element from `in` or defaultVal when `in` is empty

func Min

func Min[T number](in ...T) T

Min returns the min number from `in`.

func MinDefault

func MinDefault[T number](in ...T) T

MinDefault returns min element from `in` or default value for specified type when `in` is empty.

func MinOr

func MinOr[T number](defaultVal T, in ...T) T

MinOr returns min element from `in` or defaultVal when `in` is empty

func Pointer

func Pointer[T any](v T) *T

func Slice2Map

func Slice2Map[T comparable](in []T) map[T]struct{}

Slice2Map make map from slice, which contains all values from `in` as map keys.

func SliceAddNotExists

func SliceAddNotExists[T comparable](in []T, elem T) []T

SliceAddNotExists return `in` with `elem` inside when `elem` not exists in `in`.

func SliceAll

func SliceAll[T any](in []T, fn func(T) bool) bool

SliceAll returns true when `fn` returns true for all elements from `in`. Returns true when in is empty.

func SliceAny

func SliceAny[T any](in []T, fn func(T) bool) bool

SliceAny returns true when `fn` returns true for at least one element from `in`.

func SliceApply

func SliceApply[T any](in []T, fn func(int, T))

SliceApply handle all elements from `in` by function `fn`. Function apply sequentially.

func SliceChain

func SliceChain[T any](in ...[]T) []T

SliceChain returns a slice where all `in` slices id appended to the end. Like append(append(in[0], in[1]...), in[2]...).

func SliceChunk

func SliceChunk[T any](in []T, fn func(i int, elem T) bool) [][]T

SliceChunk split `in` into chunks by fn(index, elem) == true.

func SliceChunkEvery

func SliceChunkEvery[T any](in []T, every int) [][]T

SliceChunkEvery split `in` into chunks by size `every`

func SliceContainsElem

func SliceContainsElem[T comparable](in []T, elem T) bool

SliceContainsElem returns true when `in` contains elem.

func SliceDifference

func SliceDifference[T comparable](oldSlice, newSlice []T) []T

SliceDifference return the difference between `oldSlice` and `newSlice`. Returns only elements which presented in `newSlice` but not presented in `oldSlice`. Example: [1,2,3], [3,4,5,5,5] => [4,5,5,5]

func SliceEqualUnordered

func SliceEqualUnordered[T comparable](in1, in2 []T) bool

SliceEqualUnordered returns true when all uniq values from `in1` contains in `in2`. Useful in tests for comparing expected and actual slices. Examples:

• [1,2,3], [2,3,3,3,1,1] => true
• [1], [1,1,1] => true
• [1], [1] => true
• [1], [2] => false

func SliceFillElem

func SliceFillElem[T any](l int, elem T) []T

SliceFillElem returns the slice with len `l` where all elements are equal to `elem`.

func SliceFilter

func SliceFilter[T any](in []T, fn func(T) bool) []T

SliceFilter returns slice of values from `in` where `fn(elem) == true`.

func SliceFindAllElements

func SliceFindAllElements[T any](in []T, fn func(i int, elem T) bool) []T

SliceFindAllElements return all elem from `in` that fn(index, elem) == true.

func SliceFindAllIndexes

func SliceFindAllIndexes[T any](in []T, fn func(i int, elem T) bool) []int

SliceFindAllIndexes return all indexes from `in` that fn(index, elem) == true.

func SliceGroupBy

func SliceGroupBy[K comparable, V any](in []V, fn func(V) K) map[K][]V

SliceGroupBy will group all

func SliceIntersection

func SliceIntersection[T comparable](oldSlice, newSlice []T) []T

SliceIntersection returns elements that are presented in both slices. Example: [1,2,3], [2,4,3,3,3] => [2, 3]

func SliceMap

func SliceMap[T any, V any](in []T, fn func(T) V) []V

SliceMap returns the slice where each element of `in` was handled by `fn`.

func SliceMapErr

func SliceMapErr[T any, V any](in []T, fn func(T) (V, error)) ([]V, error)

SliceMapErr do the same thing as SliceMap, but return error when error occurs in fn.

func SliceRange

func SliceRange[T number](start, stop, step T) []T

SliceRange produces a sequence of integers from start (inclusive) to stop (exclusive) by step.

func SliceReverse

func SliceReverse[T any](in []T) []T

SliceReverse reverse the slice.

func SliceSort

func SliceSort[T any](in []T, less func(a, b T) bool)

SliceSort sort slice inplace.

func SliceSortCopy

func SliceSortCopy[T any](in []T, less func(a, b T) bool) []T

SliceSortCopy copy and sort slice.

func SliceUnion

func SliceUnion[T comparable](in ...[]T) []T

SliceUnion returns only uniq items from all slices.

func SliceUniq

func SliceUniq[T comparable](in []T) []T

SliceUniq returns only unique values from `in`.

func SliceWithout

func SliceWithout[T any](in []T, fn func(T) bool) []T

SliceWithout returns the slice `in` where fn(elem) == true.

func SliceWithoutElem

func SliceWithoutElem[T comparable](in []T, elem T) []T

SliceWithoutElem returns the slice `in` that not contains `elem`.

func SliceZip

func SliceZip[T any](in ...[]T) [][]T

SliceZip returns merged together the values of each of the arrays with the values at the corresponding position. If the len of `in` is different - will use smaller one.

func Sum

func Sum[T number](in ...T) T

Sum returns the sum of numbers from `in`.

Types

type KV

type KV[K comparable, V any] struct {
	Key K
	Val V
}

KV represents the key-value of map.

func MapPairs

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

MapPairs returns slice of KV structs that contains ket-value pairs.

type NullVal

type NullVal[T any] struct {
	Val   T    `json:"v"`
	Valid bool `json:"ok"`
}

NullVal represent the nullable value for this type.

func Null

func Null[T any](val T) NullVal[T]

Null returns NullVal for `val` type, which are `NullVal.Valid == true`.

func NullNull

func NullNull[T any]() NullVal[T]

NullNull returns NullVal, which are `NullVal.Valid == false`.

func (*NullVal[T]) Scan

func (nv *NullVal[T]) Scan(value any) error

Scan implements the Scanner interface.

func (*NullVal[T]) SetDefault

func (nv *NullVal[T]) SetDefault(val T) bool

SetDefault set value `val` if NullVal.Valid == false.

func (NullVal[T]) Value

func (nv NullVal[T]) Value() (driver.Value, error)

Value implements the driver Valuer interface.

func (NullVal[T]) ValueOk

func (nv NullVal[T]) ValueOk() (T, bool)

ValueOk returns the NullVal.Val and NullVal.Valid.

type SliceElem

type SliceElem[T any] struct {
	// Idx is index of element in slice.
	Idx int
	// Val is value on slice by Idx index.
	Val T
}

SliceElem represent element of slice.

func SliceFindAll

func SliceFindAll[T any](in []T, fn func(i int, elem T) bool) []SliceElem[T]

SliceFindAll return all elem and index from `in` that fn(index, elem) == true.

func SliceFindFirst

func SliceFindFirst[T any](in []T, fn func(i int, elem T) bool) SliceElem[T]

SliceFindFirst return first elem from `in` that fn(index, elem) == true. returns index of found elem or -1 if elem not found.

func SliceFindFirstElem

func SliceFindFirstElem[T comparable](in []T, elem T) SliceElem[T]

SliceFindFirstElem return first elem from `in` that equals to `elem`.

func SliceFindLast

func SliceFindLast[T any](in []T, fn func(i int, elem T) bool) SliceElem[T]

SliceFindLast return last elem from `in` that fn(index, elem) == true. returns index of found elem or -1 if elem not found.

func SliceFindLastElem

func SliceFindLastElem[T comparable](in []T, elem T) SliceElem[T]

SliceFindLastElem return last elem from `in` that equals to `elem`.

func (SliceElem[T]) Ok

func (e SliceElem[T]) Ok() bool

Ok returns true if Idx is valid.

func (SliceElem[T]) ValueIdx

func (e SliceElem[T]) ValueIdx() (T, int)

ValueIdx returns value and index as is. Useful for this:

elem, idx := SliceFindFirstElem([]int{1,2,3}, 2).ValueIdx()

func (SliceElem[T]) ValueOk

func (e SliceElem[T]) ValueOk() (T, bool)

ValueOk returns the value and true (when element is exists in slice) or false in other case. Useful for cases like:

if elem, ok := SliceFindFirstElem([]int{1,2,3}, 2); ok{
	fmt.Println(elem)
}