Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

util

package

Go to main page

Versions in this module

v1

v1.0.3

Sep 12, 2024

v1.0.2

Sep 9, 2024

v1.0.1

Sep 8, 2024

Changes in this version

+ var ErrorNotFound = errors.New("not found")

+ func Args(params ...interface{}) []interface

+ func AutoLock(mu *sync.Mutex, fun func())

+ func AutoRLock(mu *sync.RWMutex, fun func())

+ func AutoWLock(mu *sync.RWMutex, fun func())

+ func BoolComparator(a, b bool) int

+ func Cast(condition bool, trueFun, falseFun func())

+ func Catch(desc string, x interface{}, bFatal ...bool) bool

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

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

+ func Complex128Comparator(a, b complex128) int

+ func Complex64Comparator(a, b complex64) int

+ func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)

+ func DefaultVal[T any](vars []T) T

+ func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)

+ func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool

+ func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool

+ func ExeFullName() string

+ func ExeName() string

+ func Float32Comparator(a, b float32) int

+ func Float64Comparator(a, b float64) int

+ func FuncFullName(fun interface{}, seps ...rune) string

+ func FuncFullNameRef(valFun reflect.Value, seps ...rune) string

+ func FuncName(fun interface{}) string

+ func GoId() (int, error)

+ func Goroutine(name string, goFun func(), wg ...*sync.WaitGroup)

+ func Int16Comparator(a, b int16) int

+ func Int32Comparator(a, b int32) int

+ func Int64Comparator(a, b int64) int

+ func Int8Comparator(a, b int8) int

+ func IntComparator(a, b int) int

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

+ func Lock(mu *sync.Mutex) *sync.Mutex

+ func OrderedTypeCmp[T Ordered](a, b T) int

+ func Quit(delay ...time.Duration)

+ func RLock(mu *sync.RWMutex) *sync.RWMutex

+ func RUnLock(rMutex *sync.RWMutex)

+ func Sleep(d time.Duration)

+ func Stack(depth int) (file string, line int, fun string)

+ func StringComparator(a, b string) int

+ func StructName(obj interface{}) string

+ func Term(clearHand func(interface{}))

+ func Tern[T bool, U any](isTrue T, ifValue U, elseValue U) U

+ func TimeLived() time.Duration

+ func TimeStart() time.Time

+ func Uint16Comparator(a, b uint16) int

+ func Uint32Comparator(a, b uint32) int

+ func Uint64Comparator(a, b uint64) int

+ func Uint8Comparator(a, b uint8) int

+ func UintComparator(a, b uint) int

+ func UintptrComparator(a, b uintptr) int

+ func UnLock(lockFun *sync.Mutex)

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

+ func WLock(mu *sync.RWMutex) *sync.RWMutex

+ func WUnLock(wMutex *sync.RWMutex)

+ func Wait(x ...interface{})

+ type Comparator func(a, b T) int

+ func Reverse[T any](cmp Comparator[T]) Comparator[T]

+ type Complex interface

+ type Float interface

+ type HashMap struct

+ func NewHashMap[K comparable, V any](opts ...Option) *HashMap[K, V]

+ func (m *HashMap[K, V]) Clear()

+ func (m *HashMap[K, V]) Contains(keys ...K) bool

+ func (m *HashMap[K, V]) Erase(key K)

+ func (m *HashMap[K, V]) Find(key K) *Pair[K, V]

+ func (m *HashMap[K, V]) Get(key K) (V, bool)

+ func (m *HashMap[K, V]) Got(key K) V

+ func (m *HashMap[K, V]) Insert(key K, value V)

+ func (m *HashMap[K, V]) Inserts(pairs ...*Pair[K, V])

+ func (m *HashMap[K, V]) Iterator(iterFunc func(key K, val V))

+ func (m *HashMap[K, V]) Keys() []K

+ func (m *HashMap[K, V]) Replace(data map[K]V)

+ func (m *HashMap[K, V]) Size() int

+ func (m *HashMap[K, V]) Values() []V

+ type ILocker interface

+ Lock func() interface{}

+ UnLock func(i interface{})

+ type IRWLocker interface

+ RLock func() interface{}

+ RUnLock func(i interface{})

+ type IntStringer interface

+ type Integer interface

+ type InvalidLocker struct

+ func (l InvalidLocker) Lock() interface{}

+ func (l InvalidLocker) RLock() interface{}

+ func (l InvalidLocker) RUnLock(i interface{})

+ func (l InvalidLocker) UnLock(i interface{})

+ type Locker struct

+ func (l *Locker) Lock() interface{}

+ func (l *Locker) Mutex() *sync.Mutex

+ func (l *Locker) UnLock(i interface{})

+ type Option func(option *Options)

+ func HashMapWithSafe() Option

+ type Options struct

+ type Ordered interface

+ type Pair struct

+ func MakePair[K comparable, V any](key K, val V) *Pair[K, V]

+ func (p *Pair[K, V]) Equal(other *Pair[K, V]) bool

+ func (p *Pair[K, V]) First() K

+ func (p *Pair[K, V]) Second() V

+ func (p *Pair[K, V]) Set(key K, val V)

+ type RWLocker struct

+ func (l *RWLocker) Lock() interface{}

+ func (l *RWLocker) Mutex() *sync.RWMutex

+ func (l *RWLocker) RLock() interface{}

+ func (l *RWLocker) RUnLock(i interface{})

+ func (l *RWLocker) UnLock(i interface{})

+ type Signed interface

+ type UIntStringer interface

+ type Unsigned interface