just

package module
v0.0.0-...-b717b1a Latest Latest
Warning

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

 Go to latest Published: Mar 5, 2025 License: MIT Imports: 16 Imported by: 0

README

just

Go Reference License Build Status Go Report Card CodeCov Mentioned in Awesome Go

This project contains features that help make the noisy stuff in every project.

  • Filter slices, maps.
  • Applying functions to collections.
  • Null[any] for optional fields in API and sql.DB queries.

Most helpful functions

Examples

This library contains a bunch of functions. Please see pkg.go.dev for examples.

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source 
var FCnSte = WGiPEA()

Functions

func Abs 

func Abs[T number](v T) T

Abs returns the abs value of v.

func Bool 

func Bool[T builtin](v T) bool

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

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	fmt.Println(just.Bool(0), just.Bool(1), just.Bool(-1))
}

Output:

false true false

func ChanAdapt 

func ChanAdapt[T, D any](in <-chan T, fn func(T) D) <-chan D

ChanAdapt returns a channel, which will contain adapted messages from the source channel. The resulting channel will be closed after the source channel is closed.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
	"strconv"
)

func main() {
	intCh := make(chan int, 4)
	just.ChanPut(intCh, []int{1, 2, 3, 4})

	strCh := just.ChanAdapt(intCh, strconv.Itoa)
	fmt.Println(just.ChanReadN(strCh, 4))
}

Output:

[1 2 3 4]

func ChanPut 

func ChanPut[T any](ch chan T, elems []T)

ChanPut will put all elements into the channel synchronously.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	ch := make(chan int, 4)
	just.ChanPut(ch, []int{1, 2, 3, 4})

	resultSlice := just.ChanReadN(ch, 4)
	fmt.Println(resultSlice)
}

Output:

[1 2 3 4]

func ChanReadN 

func ChanReadN[T any](ch <-chan T, n int) []T

ChanReadN will read N messages from the channel and return the resulting slice.

func ContextWithTimeout 

func ContextWithTimeout(ctx context.Context, d time.Duration, fn func(context.Context) error) error

ContextWithTimeout will create a new context with a specified timeout and call the function with this context.

func ContextWithTimeout2 

func ContextWithTimeout2[T any](ctx context.Context, d time.Duration, fn func(context.Context) (T, error)) (T, error)

ContextWithTimeout2 will do the same as ContextWithTimeout but returns 2 arguments from the function callback.

func ErrAs 

func ErrAs[T any](err error) (T, bool)

ErrAs provide a more handful way to match the error.

Example 
err := fmt.Errorf("problem: %w", customErr{reason: 13})

e, ok := just.ErrAs[customErr](err)
fmt.Printf("%#v, %t", e, ok)

Output:

just_test.customErr{reason:13}, true

func ErrIsAnyOf 

func ErrIsAnyOf(err error, errSlice ...error) bool

ErrIsAnyOf returns true when at least one expression `errors.Is(err, errSlice[N])` return true.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
	"io"
	"math/rand"
)

func main() {
	funcWithRandomError := func() error {
		errs := []error{
			io.EOF,
			io.ErrNoProgress,
			io.ErrClosedPipe,
		}

		return errs[rand.Intn(len(errs))]
	}

	err := funcWithRandomError()
	// Instead of switch/case you can use:
	fmt.Println(just.ErrIsAnyOf(err, io.EOF, io.ErrClosedPipe, io.ErrNoProgress))
}

Output:

true

func ErrIsNotAnyOf 

func ErrIsNotAnyOf(err error, errSlice ...error) bool

ErrIsNotAnyOf returns true when all errors from errSlice are not `errors.Is(err, errSlice[N])`.

func If 

func If[T any](condition bool, val1, val2 T) T

If return val1 when condition is true; val2 in other case.

Usable to simplify constructions like: 

var username string
if request.Username != "" {
    username = request.Username
} else {
    username = "__unknown__"
}

func JsonParseType 

func JsonParseType[T any](bb []byte) (*T, error)

JsonParseType parse byte slice to specific type.

func JsonParseTypeF 

func JsonParseTypeF[T any](filename string) (*T, error)

JsonParseTypeF parse json file into specific T.

func MapApply 

func MapApply[M ~map[K]V, K comparable, V any](in M, fn func(k K, v V))

MapApply applies fn to each kv pair

func MapContainsKey 

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

MapContainsKey returns true if key is exists in the map.

func MapContainsKeysAll 

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

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

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	m := map[int]int{
		1: 10,
		2: 20,
	}
	containsAllKeys := just.MapContainsKeysAll(m, []int{1, 2})

	fmt.Println(containsAllKeys)
}

Output:

true

func MapContainsKeysAny 

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

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

func MapCopy 

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

MapCopy returns a shallow copy of the map.

func MapDefaults 

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

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 MapDropKeys 

func MapDropKeys[M ~map[K]V, K comparable, V any](in M, keys ...K)

MapDropKeys remove all keys from the source map. Map will change in place.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	m := map[int]int{
		1: 10,
		2: 20,
	}
	just.MapDropKeys(m, 1, 3)

	fmt.Printf("%#v", m)
}

Output:

map[int]int{2:20}

func MapFilter 

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

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

func MapFilterKeys 

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

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

func MapFilterValues 

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

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

func MapGetDefault 

func MapGetDefault[M ~map[K]V, K comparable, V any](in M, key K, defaultVal V) V

MapGetDefault returns a value for a given key or default value if the key is not present in the source map.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	m := map[int]int{
		1: 10,
		2: 20,
	}
	val := just.MapGetDefault(m, 3, 42)
	fmt.Println(val)
}

Output:

42

func MapGetKeys 

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

MapGetKeys returns all keys of the map.

func MapGetValues 

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

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

func MapJoin 

func MapJoin[M ~map[K]V, K comparable, V any](maps ...M) M

MapJoin will create a new map containing all key-value pairs from app input maps. If several maps have duplicate keys - the last write wins.

func MapMap 

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

MapMap applies fn to all kv pairs from in.

func MapMapErr 

func MapMapErr[M ~map[K]V, K, K1 comparable, V, V1 any](in M, fn func(K, V) (K1, V1, error)) (map[K1]V1, error)

MapMapErr applies fn to all kv pairs from in.

func MapMerge 

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

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

func MapNotNil 

func MapNotNil[T ~map[K]V, K comparable, V any](in T) T

MapNotNil returns the source map when it is not nil or creates an empty instance of this type.

func MapPopKeyDefault 

func MapPopKeyDefault[M ~map[K]V, K comparable, V any](in M, key K, def V) V

MapPopKeyDefault will return value for given key and delete this key from source map. In case of key do not presented in map - returns default value.

func MapSetVal 

func MapSetVal[M ~map[K]V, K comparable, V any](in M, key K, val V) M

MapSetVal update key with value for given map and return updated map.

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 the max element from `in` or the default value for a specified type when `in` is empty.

func MaxOr 

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

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

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	values := []int{10, 20, 30}
	maxValue := just.MaxOr(999, values...)
	// This will print 30, because you have non-empty slice.
	fmt.Println(maxValue)
}

Output:

30

func Min 

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

Min returns the min number from `in`.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	values := []int{10, 20, 30}
	minValue := just.Min(values...)
	fmt.Println(minValue)
}

Output:

10

func MinDefault 

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

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

func MinOr 

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

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

func Must 

func Must[T any](val T, err error) T

Must will panic on an error after calling typical function.

Example 
package main

import (
	"bytes"
	"fmt"
	"github.com/violentchard/just"
	"io"
)

func main() {
	val := just.Must(io.ReadAll(bytes.NewBufferString("this is body!")))
	fmt.Println(string(val))
}

Output:

this is body!

func Pointer 

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

Pointer returns a pointer to `v`.

func PointerUnwrap 

func PointerUnwrap[T any](in *T) T

PointerUnwrap returns the value from the pointer.

func PointerUnwrapDefault 

func PointerUnwrapDefault[T builtin | any](in *T, defaultVal T) T

PointerUnwrapDefault returns a value from pointer or defaultVal when input is an empty pointer.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	someFuncThatReturnsNil := func() *int { return nil }

	value := just.PointerUnwrapDefault(someFuncThatReturnsNil(), 42)
	fmt.Println(value)
}

Output:

42

func RunAfter 

func RunAfter(ctx context.Context, ticker <-chan time.Time, runNow bool, fn func(ctx context.Context) error) error

func Slice2Chan 

func Slice2Chan[T any](in []T, capacity int) chan T

Slice2Chan make chan with specified capacity from source slice.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30, 40, 50}
	ch := just.Slice2Chan(input, 0)
	result := just.ChanReadN(ch, 5)
	fmt.Println(result)
}

Output:

[10 20 30 40 50]

func Slice2ChanFill 

func Slice2ChanFill[T any](in []T) chan T

Slice2ChanFill make chan from source slice with will already filled by all elements from source slice.

func Slice2Iter 

func Slice2Iter[T any](in []T) func(func(int, T) bool)

Slice2Iter create an iterator from slice. Check this docs https://go.dev/ref/spec#For_range.

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.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30, 30}
	result := just.Slice2Map(input)
	fmt.Println(result)
}

Output:

map[10:{} 20:{} 30:{}]

func Slice2MapFn 

func Slice2MapFn[T any, K comparable, V any](in []T, fn func(idx int, elem T) (K, V)) map[K]V

Slice2MapFn apply fn to every elem. fn should return key and value, which will be applied to result map.

func Slice2MapFnErr 

func Slice2MapFnErr[T any, K comparable, V any](in []T, fn func(idx int, elem T) (K, V, error)) (map[K]V, error)

Slice2MapFnErr apply fn to every elem. fn should return key and value, which will be applied to result map. return error when at least one fn returns an error.

func SliceAddNotExists 

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

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

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30}
	result := just.SliceAddNotExists(input, 42)
	fmt.Println(result)
}

Output:

[10 20 30 42]

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 handles all elements from `in` by function `fn`. Function applies sequentially.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30}
	just.SliceApply(input, func(i int, v int) {
		fmt.Println(i, v)
	})
}

Output:

0 10
1 20
2 30

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`

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30, 40, 50}
	result := just.SliceChunkEvery(input, 2)
	fmt.Println(result)
}

Output:

[[10 20] [30 40] [50]]

func SliceContainsElem 

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

SliceContainsElem returns true when `in` contains elem.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30}
	contains20 := just.SliceContainsElem(input, 20)
	fmt.Println(contains20)
}

Output:

true

func SliceCopy 

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

SliceCopy return a copy of source slice.

func SliceDifference 

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

SliceDifference returns the difference between `oldSlice` and `newSlice`. Returns only elements 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 a slice of values from `in` where `fn(elem) == true`.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	input := []int{10, 20, 30}
	filtered := just.SliceFilter(input, func(v int) bool {
		return v > 15
	})
	fmt.Println(filtered)
}

Output:

[20 30]

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 SliceFlatMap 

func SliceFlatMap[T, V any](in []T, fn func(val T) []V) []V

SliceFlatMap applies `fn` to each element of `in` and join all output slices.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
	"strconv"
)

func main() {
	input := []int{1, 2, 3}
	result := just.SliceFlatMap(input, func(i int) []string {
		return []string{strconv.Itoa(i), strconv.Itoa(i)}
	})
	fmt.Println(result)
}

Output:

[1 1 2 2 3 3]

func SliceFlatMap2 

func SliceFlatMap2[T, V any](in []T, fn func(i int, val T) []V) []V

SliceFlatMap2 does the same as SliceFlatMap but receives the index of the element.

func SliceFromElem 

func SliceFromElem[T any](elem T) []T

SliceFromElem return a slice which contains only one element `elem`.

func SliceGetFirstN 

func SliceGetFirstN[T any](in []T, maxElems int) []T

SliceGetFirstN return a subslice of source slice, which will contains not more than `maxElems` items.

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 SliceIter 

func SliceIter[T any](in []T) func(func(IterContext, T) bool)

SliceIter create an iterator from slice. The first argument will contain a useful context struct.

func SliceLastDefault 

func SliceLastDefault[T any](in []T, defaultVal T) T

SliceLastDefault return a last elem from slice or default value in case of zero slice.

func SliceLastN 

func SliceLastN[T any](in []T, n int) []T

SliceLastN return up to last n elements from input slice in original order.

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

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	unsignedIntegers := []uint{1, 2, 3, 4}
	multiply := func(i uint) int { return int(i) * 10 }
	integers := just.SliceMap(unsignedIntegers, multiply)
	fmt.Println(integers)
}

Output:

[10 20 30 40]

func SliceMapErr 

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

SliceMapErr does the same thing as SliceMap but returns an error when an error occurs in fn.

func SliceNotNil 

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

SliceNotNil return source slice when it is not nil or create empty instance of this type.

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 SliceReplaceFirst 

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

SliceReplaceFirst will replace the first element in `in` such that fn(index, elem) == true. Will do nothing if the element is not found.

func SliceReplaceFirstOrAdd 

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

SliceReplaceFirstOrAdd will replace the first element in `in` such that fn(index, elem) == true. Will add a `newElem` if the element is not found.

func SliceReverse 

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

SliceReverse reverse the slice.

func SliceShuffle 

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

SliceShuffle will shuffle the slice in-place.

func SliceShuffleCopy 

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

SliceShuffleCopy will make a copy and shuffle 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 unique values from `in`.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
	"sort"
)

func main() {
	data := []int{1, 1, 2, 2, 3, 3}
	uniqData := just.SliceUniq(data)
	sort.Ints(uniqData)
	fmt.Println(uniqData)
}

Output:

[1 2 3]

func SliceUniqStable 

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

SliceUniqStable returns unique values from `in`. Keep original ordering.

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 StrCharCount 

func StrCharCount(s string) int

StrCharCount returns rune count in string.

func StrGetFirst 

func StrGetFirst(s string, n int) string

StrGetFirst return string contains first N valid chars.

func StrSplitByChars 

func StrSplitByChars(s string) []rune

StrSplitByChars returns slice of runes in string.

func Sum 

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

Sum returns the sum of numbers from `in`.

Example 
package main

import (
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	values := []int{10, 20, 30}
	minValue := just.Sum(values...)
	fmt.Println(minValue)
}

Output:

60

func WGiPEA 

func WGiPEA() error

Types

type IterContext 

type IterContext interface {
	// Idx returns an element index
	Idx() int
	RevIdx() int
	IsFirst() bool
	IsLast() bool
}

type KV 

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

KV represents the key-value of the map.

func MapPairs 

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

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

type NullVal 

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

NullVal represents the nullable value for this type. Deprecated: Use github.com/kazhuravlev/optional.

func Null 

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

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

func NullDefaultFalse 

func NullDefaultFalse[T comparable](val T) NullVal[T]

NullDefaultFalse returns NullVal for this type with Valid=true only when `val` is not equal to default value of type T.

func NullNull 

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

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

func (NullVal[T]) MarshalYAML 

func (nv NullVal[T]) MarshalYAML() ([]byte, error)

MarshalYAML implements the interface for marshaling yaml.

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]) UnmarshalYAML 

func (nv *NullVal[T]) UnmarshalYAML(bb []byte) error

UnmarshalYAML implements the interface for unmarshalling yaml.

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 Pool 

type Pool[T any] struct {
	// contains filtered or unexported fields
}

func NewPool 

func NewPool[T any](constructor func() T, reset func(T)) *Pool[T]

NewPool returns a new pool with concrete type and resets fn.

Example 
package main

import (
	"bytes"
	"fmt"
	"github.com/violentchard/just"
)

func main() {
	p := just.NewPool(
		func() *bytes.Buffer { return bytes.NewBuffer(nil) },
		func(buf *bytes.Buffer) { fmt.Println(buf.String()); buf.Reset() },
	)

	buf := p.Get()
	buf.WriteString("Some data")
	// This example showing that Pool will call reset callback
	// on each Pool.Put call.
	p.Put(buf)
}

Output:

Some data

func (*Pool[T]) Get 

func (p *Pool[T]) Get() T

Get return another object from the pool.

func (*Pool[T]) Put 

func (p *Pool[T]) Put(obj T)

Put will reset the object and put this object to the pool.

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)
}

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.