github.com/samber/lo.Async1
::
func[A any](f func() A) <-chan A
github.com/samber/lo.Async
::
func[A any](f func() A) <-chan A
math/bits.LeadingZeros
::
func(x uint) int
math/bits.LeadingZeros8
::
func(x uint8) int
math/bits.LeadingZeros16
::
func(x uint16) int
math/bits.LeadingZeros32
::
func(x uint32) int
math/bits.LeadingZeros64
::
func(x uint64) int
math/bits.TrailingZeros
::
func(x uint) int
math/bits.TrailingZeros8
::
func(x uint8) int
math/bits.TrailingZeros16
::
func(x uint16) int
math/bits.TrailingZeros32
::
func(x uint32) int
math/bits.TrailingZeros64
::
func(x uint64) int
math/bits.OnesCount
::
func(x uint) int
math/bits.OnesCount8
::
func(x uint8) int
math/bits.OnesCount16
::
func(x uint16) int
math/bits.OnesCount32
::
func(x uint32) int
math/bits.OnesCount64
::
func(x uint64) int
math/bits.RotateLeft
::
func(x uint, k int) uint
math/bits.RotateLeft8
::
func(x uint8, k int) uint8
math/bits.RotateLeft16
::
func(x uint16, k int) uint16
math/bits.RotateLeft32
::
func(x uint32, k int) uint32
math/bits.RotateLeft64
::
func(x uint64, k int) uint64
math/bits.Reverse
::
func(x uint) uint
math/bits.Reverse8
::
func(x uint8) uint8
math/bits.Reverse16
::
func(x uint16) uint16
math/bits.Reverse32
::
func(x uint32) uint32
math/bits.Reverse64
::
func(x uint64) uint64
math/bits.ReverseBytes
::
func(x uint) uint
math/bits.ReverseBytes16
::
func(x uint16) uint16
math/bits.ReverseBytes32
::
func(x uint32) uint32
math/bits.ReverseBytes64
::
func(x uint64) uint64
math/bits.Len
::
func(x uint) int
math/bits.Len8
::
func(x uint8) int
math/bits.Len16
::
func(x uint16) (n int)
math/bits.Len32
::
func(x uint32) (n int)
math/bits.Len64
::
func(x uint64) (n int)
math/bits.Add
::
func(x uint, y uint, carry uint) (sum uint, carryOut uint)
math/bits.Add32
::
func(x uint32, y uint32, carry uint32) (sum uint32, carryOut uint32)
math/bits.Add64
::
func(x uint64, y uint64, carry uint64) (sum uint64, carryOut uint64)
math/bits.Sub
::
func(x uint, y uint, borrow uint) (diff uint, borrowOut uint)
math/bits.Sub32
::
func(x uint32, y uint32, borrow uint32) (diff uint32, borrowOut uint32)
math/bits.Sub64
::
func(x uint64, y uint64, borrow uint64) (diff uint64, borrowOut uint64)
math/bits.Mul
::
func(x uint, y uint) (hi uint, lo uint)
math/bits.Mul32
::
func(x uint32, y uint32) (hi uint32, lo uint32)
math/bits.Mul64
::
func(x uint64, y uint64) (hi uint64, lo uint64)
math/bits.Div
::
func(hi uint, lo uint, y uint) (quo uint, rem uint)
math/bits.Div32
::
func(hi uint32, lo uint32, y uint32) (quo uint32, rem uint32)
math/bits.Div64
::
func(hi uint64, lo uint64, y uint64) (quo uint64, rem uint64)
math/bits.Rem
::
func(hi uint, lo uint, y uint) uint
math/bits.Rem32
::
func(hi uint32, lo uint32, y uint32) uint32
math/bits.Rem64
::
func(hi uint64, lo uint64, y uint64) uint64
golang.org/x/exp/slices.Equal
::
func[S ~[]E, E comparable](s1 S, s2 S) bool
golang.org/x/exp/slices.EqualFunc
::
func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool
golang.org/x/exp/slices.Compare
::
func[S ~[]E, E golang.org/x/exp/constraints.Ordered](s1 S, s2 S) int
golang.org/x/exp/slices.CompareFunc
::
func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int
golang.org/x/exp/slices.Index
::
func[S ~[]E, E comparable](s S, v E) int
golang.org/x/exp/slices.IndexFunc
::
func[S ~[]E, E any](s S, f func(E) bool) int
golang.org/x/exp/slices.Contains
::
func[S ~[]E, E comparable](s S, v E) bool
golang.org/x/exp/slices.ContainsFunc
::
func[S ~[]E, E any](s S, f func(E) bool) bool
golang.org/x/exp/slices.Insert
::
func[S ~[]E, E any](s S, i int, v ...E) S
golang.org/x/exp/slices.Delete
::
func[S ~[]E, E any](s S, i int, j int) S
golang.org/x/exp/slices.DeleteFunc
::
func[S ~[]E, E any](s S, del func(E) bool) S
golang.org/x/exp/slices.Replace
::
func[S ~[]E, E any](s S, i int, j int, v ...E) S
golang.org/x/exp/slices.Clone
::
func[S ~[]E, E any](s S) S
golang.org/x/exp/slices.Compact
::
func[S ~[]E, E comparable](s S) S
golang.org/x/exp/slices.CompactFunc
::
func[S ~[]E, E any](s S, eq func(E, E) bool) S
golang.org/x/exp/slices.Grow
::
func[S ~[]E, E any](s S, n int) S
golang.org/x/exp/slices.Clip
::
func[S ~[]E, E any](s S) S
golang.org/x/exp/slices.Reverse
::
func[S ~[]E, E any](s S)
golang.org/x/exp/slices.Sort
::
func[S ~[]E, E golang.org/x/exp/constraints.Ordered](x S)
golang.org/x/exp/slices.SortFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int)
golang.org/x/exp/slices.SortStableFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int)
golang.org/x/exp/slices.IsSorted
::
func[S ~[]E, E golang.org/x/exp/constraints.Ordered](x S) bool
golang.org/x/exp/slices.IsSortedFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int) bool
golang.org/x/exp/slices.Min
::
func[S ~[]E, E golang.org/x/exp/constraints.Ordered](x S) E
golang.org/x/exp/slices.MinFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int) E
golang.org/x/exp/slices.Max
::
func[S ~[]E, E golang.org/x/exp/constraints.Ordered](x S) E
golang.org/x/exp/slices.MaxFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int) E
golang.org/x/exp/slices.BinarySearch
::
func[S ~[]E, E golang.org/x/exp/constraints.Ordered](x S, target E) (int, bool)
golang.org/x/exp/slices.BinarySearchFunc
::
func[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)
internal/abi.CommonSize
::
func(ptrSize int) int
internal/abi.StructFieldSize
::
func(ptrSize int) int
internal/abi.UncommonSize
::
func() uint64
internal/abi.TFlagOff
::
func(ptrSize int) int
internal/abi.FuncPCABI0
::
func(f interface{}) uintptr
internal/abi.FuncPCABIInternal
::
func(f interface{}) uintptr
internal/abi.UseInterfaceSwitchCache
::
func(goarch string) bool
internal/abi.NewName
::
func(n string, tag string, exported bool, embedded bool) internal/abi.Name
internal/cpu.Initialize
::
func(env string)
internal/cpu.Name
::
func() string
internal/bytealg.HashStr
::
func[T string | []byte](sep T) (uint32, uint32)
internal/bytealg.HashStrRev
::
func[T string | []byte](sep T) (uint32, uint32)
internal/bytealg.IndexRabinKarp
::
func[T string | []byte](s T, sep T) int
internal/bytealg.LastIndexRabinKarp
::
func[T string | []byte](s T, sep T) int
internal/bytealg.MakeNoZero
::
func(n int) []byte
internal/bytealg.Compare
::
func(a []byte, b []byte) int
internal/bytealg.Count
::
func(b []byte, c byte) int
internal/bytealg.CountString
::
func(s string, c byte) int
internal/bytealg.Equal
::
func(a []byte, b []byte) bool
internal/bytealg.Cutover
::
func(n int) int
internal/bytealg.Index
::
func(a []byte, b []byte) int
internal/bytealg.IndexString
::
func(a string, b string) int
internal/bytealg.IndexByte
::
func(b []byte, c byte) int
internal/bytealg.IndexByteString
::
func(s string, c byte) int
internal/bytealg.LastIndexByte
::
func(s []byte, c byte) int
internal/bytealg.LastIndexByteString
::
func(s string, c byte) int
internal/chacha8rand.Marshal
::
func(s *internal/chacha8rand.State) []byte
internal/chacha8rand.Unmarshal
::
func(s *internal/chacha8rand.State, data []byte) error
internal/godebugs.Lookup
::
func(name string) *internal/godebugs.Info
runtime/internal/atomic.Load
::
func(ptr *uint32) uint32
runtime/internal/atomic.Loadp
::
func(ptr unsafe.Pointer) unsafe.Pointer
runtime/internal/atomic.Load64
::
func(ptr *uint64) uint64
runtime/internal/atomic.LoadAcq
::
func(ptr *uint32) uint32
runtime/internal/atomic.LoadAcq64
::
func(ptr *uint64) uint64
runtime/internal/atomic.LoadAcquintptr
::
func(ptr *uintptr) uintptr
runtime/internal/atomic.Xadd
::
func(ptr *uint32, delta int32) uint32
runtime/internal/atomic.Xadd64
::
func(ptr *uint64, delta int64) uint64
runtime/internal/atomic.Xadduintptr
::
func(ptr *uintptr, delta uintptr) uintptr
runtime/internal/atomic.Xchg
::
func(ptr *uint32, new uint32) uint32
runtime/internal/atomic.Xchg64
::
func(ptr *uint64, new uint64) uint64
runtime/internal/atomic.Xchguintptr
::
func(ptr *uintptr, new uintptr) uintptr
runtime/internal/atomic.Load8
::
func(ptr *uint8) uint8
runtime/internal/atomic.And8
::
func(ptr *uint8, val uint8)
runtime/internal/atomic.Or8
::
func(ptr *uint8, val uint8)
runtime/internal/atomic.And
::
func(ptr *uint32, val uint32)
runtime/internal/atomic.Or
::
func(ptr *uint32, val uint32)
runtime/internal/atomic.And32
::
func(ptr *uint32, val uint32) uint32
runtime/internal/atomic.Or32
::
func(ptr *uint32, val uint32) uint32
runtime/internal/atomic.And64
::
func(ptr *uint64, val uint64) uint64
runtime/internal/atomic.Or64
::
func(ptr *uint64, val uint64) uint64
runtime/internal/atomic.Anduintptr
::
func(ptr *uintptr, val uintptr) uintptr
runtime/internal/atomic.Oruintptr
::
func(ptr *uintptr, val uintptr) uintptr
runtime/internal/atomic.Cas64
::
func(ptr *uint64, old uint64, new uint64) bool
runtime/internal/atomic.CasRel
::
func(ptr *uint32, old uint32, new uint32) bool
runtime/internal/atomic.Store
::
func(ptr *uint32, val uint32)
runtime/internal/atomic.Store8
::
func(ptr *uint8, val uint8)
runtime/internal/atomic.Store64
::
func(ptr *uint64, val uint64)
runtime/internal/atomic.StoreRel
::
func(ptr *uint32, val uint32)
runtime/internal/atomic.StoreRel64
::
func(ptr *uint64, val uint64)
runtime/internal/atomic.StoreReluintptr
::
func(ptr *uintptr, val uintptr)
runtime/internal/atomic.StorepNoWB
::
func(ptr unsafe.Pointer, val unsafe.Pointer)
runtime/internal/atomic.Cas
::
func(ptr *uint32, old uint32, new uint32) bool
runtime/internal/atomic.Casp1
::
func(ptr *unsafe.Pointer, old unsafe.Pointer, new unsafe.Pointer) bool
runtime/internal/atomic.Casint32
::
func(ptr *int32, old int32, new int32) bool
runtime/internal/atomic.Casint64
::
func(ptr *int64, old int64, new int64) bool
runtime/internal/atomic.Casuintptr
::
func(ptr *uintptr, old uintptr, new uintptr) bool
runtime/internal/atomic.Storeint32
::
func(ptr *int32, new int32)
runtime/internal/atomic.Storeint64
::
func(ptr *int64, new int64)
runtime/internal/atomic.Storeuintptr
::
func(ptr *uintptr, new uintptr)
runtime/internal/atomic.Loaduintptr
::
func(ptr *uintptr) uintptr
runtime/internal/atomic.Loaduint
::
func(ptr *uint) uint
runtime/internal/atomic.Loadint32
::
func(ptr *int32) int32
runtime/internal/atomic.Loadint64
::
func(ptr *int64) int64
runtime/internal/atomic.Xaddint32
::
func(ptr *int32, delta int32) int32
runtime/internal/atomic.Xaddint64
::
func(ptr *int64, delta int64) int64
runtime/internal/atomic.Xchgint32
::
func(ptr *int32, new int32) int32
runtime/internal/atomic.Xchgint64
::
func(ptr *int64, new int64) int64
runtime/internal/math.MulUintptr
::
func(a uintptr, b uintptr) (uintptr, bool)
runtime/internal/math.Mul64
::
func(x uint64, y uint64) (hi uint64, lo uint64)
runtime/internal/math.Add64
::
func(x uint64, y uint64, carry uint64) (sum uint64, carryOut uint64)
runtime/internal/sys.TrailingZeros32
::
func(x uint32) int
runtime/internal/sys.TrailingZeros64
::
func(x uint64) int
runtime/internal/sys.TrailingZeros8
::
func(x uint8) int
runtime/internal/sys.Len64
::
func(x uint64) (n int)
runtime/internal/sys.OnesCount64
::
func(x uint64) int
runtime/internal/sys.LeadingZeros64
::
func(x uint64) int
runtime/internal/sys.LeadingZeros8
::
func(x uint8) int
runtime/internal/sys.Len8
::
func(x uint8) int
runtime/internal/sys.Bswap64
::
func(x uint64) uint64
runtime/internal/sys.Bswap32
::
func(x uint32) uint32
runtime/internal/sys.Prefetch
::
func(addr uintptr)
runtime/internal/sys.PrefetchStreamed
::
func(addr uintptr)
runtime/internal/syscall.Syscall6
::
func(num uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, errno uintptr)
runtime/internal/syscall.EpollCreate1
::
func(flags int32) (fd int32, errno uintptr)
runtime/internal/syscall.EpollWait
::
func(epfd int32, events []runtime/internal/syscall.EpollEvent, maxev int32, waitms int32) (n int32, errno uintptr)
runtime/internal/syscall.EpollCtl
::
func(epfd int32, op int32, fd int32, event *runtime/internal/syscall.EpollEvent) (errno uintptr)
runtime.SetCPUProfileRate
::
func(hz int)
runtime.CPUProfile
::
func() []byte
runtime.GOMAXPROCS
::
func(n int) int
runtime.NumCPU
::
func() int
runtime.NumCgoCall
::
func() int64
runtime.NumGoroutine
::
func() int
runtime.Caller
::
func(skip int) (pc uintptr, file string, line int, ok bool)
runtime.Callers
::
func(skip int, pc []uintptr) int
runtime.GOROOT
::
func() string
runtime.Version
::
func() string
runtime.SetFinalizer
::
func(obj any, finalizer any)
runtime.KeepAlive
::
func(x any)
runtime.GC
::
func()
runtime.SetBlockProfileRate
::
func(rate int)
runtime.SetMutexProfileFraction
::
func(rate int) int
runtime.MemProfile
::
func(p []runtime.MemProfileRecord, inuseZero bool) (n int, ok bool)
runtime.BlockProfile
::
func(p []runtime.BlockProfileRecord) (n int, ok bool)
runtime.MutexProfile
::
func(p []runtime.BlockProfileRecord) (n int, ok bool)
runtime.ThreadCreateProfile
::
func(p []runtime.StackRecord) (n int, ok bool)
runtime.GoroutineProfile
::
func(p []runtime.StackRecord) (n int, ok bool)
runtime.Stack
::
func(buf []byte, all bool) int
runtime.ReadMemStats
::
func(m *runtime.MemStats)
runtime.Goexit
::
func()
runtime.Gosched
::
func()
runtime.Breakpoint
::
func()
runtime.LockOSThread
::
func()
runtime.UnlockOSThread
::
func()
runtime.CallersFrames
::
func(callers []uintptr) *runtime.Frames
runtime.FuncForPC
::
func(pc uintptr) *runtime.Func
runtime.StartTrace
::
func() error
runtime.StopTrace
::
func()
runtime.ReadTrace
::
func() []byte
runtime.SetCgoTraceback
::
func(version int, traceback unsafe.Pointer, context unsafe.Pointer, symbolizer unsafe.Pointer)
internal/reflectlite.Swapper
::
func(slice any) func(i int, j int)
internal/reflectlite.TypeOf
::
func(i any) internal/reflectlite.Type
internal/reflectlite.ValueOf
::
func(i any) internal/reflectlite.Value
errors.New
::
func(text string) error
errors.Join
::
func(errs ...error) error
errors.Unwrap
::
func(err error) error
errors.Is
::
func(err error, target error) bool
errors.As
::
func(err error, target any) bool
internal/itoa.Itoa
::
func(val int) string
internal/itoa.Uitoa
::
func(val uint) string
internal/itoa.Uitox
::
func(val uint) string
math.Abs
::
func(x float64) float64
math.Acosh
::
func(x float64) float64
math.Asin
::
func(x float64) float64
math.Acos
::
func(x float64) float64
math.Asinh
::
func(x float64) float64
math.Atan
::
func(x float64) float64
math.Atan2
::
func(y float64, x float64) float64
math.Atanh
::
func(x float64) float64
math.Inf
::
func(sign int) float64
math.NaN
::
func() float64
math.IsNaN
::
func(f float64) (is bool)
math.IsInf
::
func(f float64, sign int) bool
math.Cbrt
::
func(x float64) float64
math.Copysign
::
func(f float64, sign float64) float64
math.Dim
::
func(x float64, y float64) float64
math.Max
::
func(x float64, y float64) float64
math.Min
::
func(x float64, y float64) float64
math.Erf
::
func(x float64) float64
math.Erfc
::
func(x float64) float64
math.Erfinv
::
func(x float64) float64
math.Erfcinv
::
func(x float64) float64
math.Exp
::
func(x float64) float64
math.Exp2
::
func(x float64) float64
math.Expm1
::
func(x float64) float64
math.Floor
::
func(x float64) float64
math.Ceil
::
func(x float64) float64
math.Trunc
::
func(x float64) float64
math.Round
::
func(x float64) float64
math.RoundToEven
::
func(x float64) float64
math.FMA
::
func(x float64, y float64, z float64) float64
math.Frexp
::
func(f float64) (frac float64, exp int)
math.Gamma
::
func(x float64) float64
math.Hypot
::
func(p float64, q float64) float64
math.J0
::
func(x float64) float64
math.Y0
::
func(x float64) float64
math.J1
::
func(x float64) float64
math.Y1
::
func(x float64) float64
math.Jn
::
func(n int, x float64) float64
math.Yn
::
func(n int, x float64) float64
math.Ldexp
::
func(frac float64, exp int) float64
math.Lgamma
::
func(x float64) (lgamma float64, sign int)
math.Log
::
func(x float64) float64
math.Log10
::
func(x float64) float64
math.Log2
::
func(x float64) float64
math.Log1p
::
func(x float64) float64
math.Logb
::
func(x float64) float64
math.Ilogb
::
func(x float64) int
math.Mod
::
func(x float64, y float64) float64
math.Modf
::
func(f float64) (int float64, frac float64)
math.Nextafter32
::
func(x float32, y float32) (r float32)
math.Nextafter
::
func(x float64, y float64) (r float64)
math.Pow
::
func(x float64, y float64) float64
math.Pow10
::
func(n int) float64
math.Remainder
::
func(x float64, y float64) float64
math.Signbit
::
func(x float64) bool
math.Cos
::
func(x float64) float64
math.Sin
::
func(x float64) float64
math.Sincos
::
func(x float64) (sin float64, cos float64)
math.Sinh
::
func(x float64) float64
math.Cosh
::
func(x float64) float64
math.Sqrt
::
func(x float64) float64
math.Tan
::
func(x float64) float64
math.Tanh
::
func(x float64) float64
math.Float32bits
::
func(f float32) uint32
math.Float32frombits
::
func(b uint32) float32
math.Float64bits
::
func(f float64) uint64
math.Float64frombits
::
func(b uint64) float64
unicode/utf8.FullRune
::
func(p []byte) bool
unicode/utf8.FullRuneInString
::
func(s string) bool
unicode/utf8.DecodeRune
::
func(p []byte) (r rune, size int)
unicode/utf8.DecodeRuneInString
::
func(s string) (r rune, size int)
unicode/utf8.DecodeLastRune
::
func(p []byte) (r rune, size int)
unicode/utf8.DecodeLastRuneInString
::
func(s string) (r rune, size int)
unicode/utf8.RuneLen
::
func(r rune) int
unicode/utf8.EncodeRune
::
func(p []byte, r rune) int
unicode/utf8.AppendRune
::
func(p []byte, r rune) []byte
unicode/utf8.RuneCount
::
func(p []byte) int
unicode/utf8.RuneCountInString
::
func(s string) (n int)
unicode/utf8.RuneStart
::
func(b byte) bool
unicode/utf8.Valid
::
func(p []byte) bool
unicode/utf8.ValidString
::
func(s string) bool
unicode/utf8.ValidRune
::
func(r rune) bool
strconv.ParseBool
::
func(str string) (bool, error)
strconv.FormatBool
::
func(b bool) string
strconv.AppendBool
::
func(dst []byte, b bool) []byte
strconv.ParseComplex
::
func(s string, bitSize int) (complex128, error)
strconv.ParseFloat
::
func(s string, bitSize int) (float64, error)
strconv.ParseUint
::
func(s string, base int, bitSize int) (uint64, error)
strconv.ParseInt
::
func(s string, base int, bitSize int) (i int64, err error)
strconv.Atoi
::
func(s string) (int, error)
strconv.FormatComplex
::
func(c complex128, fmt byte, prec int, bitSize int) string
strconv.FormatFloat
::
func(f float64, fmt byte, prec int, bitSize int) string
strconv.AppendFloat
::
func(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte
strconv.FormatUint
::
func(i uint64, base int) string
strconv.FormatInt
::
func(i int64, base int) string
strconv.Itoa
::
func(i int) string
strconv.AppendInt
::
func(dst []byte, i int64, base int) []byte
strconv.AppendUint
::
func(dst []byte, i uint64, base int) []byte
strconv.Quote
::
func(s string) string
strconv.AppendQuote
::
func(dst []byte, s string) []byte
strconv.QuoteToASCII
::
func(s string) string
strconv.AppendQuoteToASCII
::
func(dst []byte, s string) []byte
strconv.QuoteToGraphic
::
func(s string) string
strconv.AppendQuoteToGraphic
::
func(dst []byte, s string) []byte
strconv.QuoteRune
::
func(r rune) string
strconv.AppendQuoteRune
::
func(dst []byte, r rune) []byte
strconv.QuoteRuneToASCII
::
func(r rune) string
strconv.AppendQuoteRuneToASCII
::
func(dst []byte, r rune) []byte
strconv.QuoteRuneToGraphic
::
func(r rune) string
strconv.AppendQuoteRuneToGraphic
::
func(dst []byte, r rune) []byte
strconv.CanBackquote
::
func(s string) bool
strconv.UnquoteChar
::
func(s string, quote byte) (value rune, multibyte bool, tail string, err error)
strconv.QuotedPrefix
::
func(s string) (string, error)
strconv.Unquote
::
func(s string) (string, error)
strconv.IsPrint
::
func(r rune) bool
strconv.IsGraphic
::
func(r rune) bool
internal/race.Acquire
::
func(addr unsafe.Pointer)
internal/race.Release
::
func(addr unsafe.Pointer)
internal/race.ReleaseMerge
::
func(addr unsafe.Pointer)
internal/race.Disable
::
func()
internal/race.Enable
::
func()
internal/race.Read
::
func(addr unsafe.Pointer)
internal/race.Write
::
func(addr unsafe.Pointer)
internal/race.ReadRange
::
func(addr unsafe.Pointer, len int)
internal/race.WriteRange
::
func(addr unsafe.Pointer, len int)
internal/race.Errors
::
func() int
sync/atomic.SwapInt32
::
func(addr *int32, new int32) (old int32)
sync/atomic.SwapInt64
::
func(addr *int64, new int64) (old int64)
sync/atomic.SwapUint32
::
func(addr *uint32, new uint32) (old uint32)
sync/atomic.SwapUint64
::
func(addr *uint64, new uint64) (old uint64)
sync/atomic.SwapUintptr
::
func(addr *uintptr, new uintptr) (old uintptr)
sync/atomic.SwapPointer
::
func(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
sync/atomic.CompareAndSwapInt32
::
func(addr *int32, old int32, new int32) (swapped bool)
sync/atomic.CompareAndSwapInt64
::
func(addr *int64, old int64, new int64) (swapped bool)
sync/atomic.CompareAndSwapUint32
::
func(addr *uint32, old uint32, new uint32) (swapped bool)
sync/atomic.CompareAndSwapUint64
::
func(addr *uint64, old uint64, new uint64) (swapped bool)
sync/atomic.CompareAndSwapUintptr
::
func(addr *uintptr, old uintptr, new uintptr) (swapped bool)
sync/atomic.CompareAndSwapPointer
::
func(addr *unsafe.Pointer, old unsafe.Pointer, new unsafe.Pointer) (swapped bool)
sync/atomic.AddInt32
::
func(addr *int32, delta int32) (new int32)
sync/atomic.AddUint32
::
func(addr *uint32, delta uint32) (new uint32)
sync/atomic.AddInt64
::
func(addr *int64, delta int64) (new int64)
sync/atomic.AddUint64
::
func(addr *uint64, delta uint64) (new uint64)
sync/atomic.AddUintptr
::
func(addr *uintptr, delta uintptr) (new uintptr)
sync/atomic.LoadInt32
::
func(addr *int32) (val int32)
sync/atomic.LoadInt64
::
func(addr *int64) (val int64)
sync/atomic.LoadUint32
::
func(addr *uint32) (val uint32)
sync/atomic.LoadUint64
::
func(addr *uint64) (val uint64)
sync/atomic.LoadUintptr
::
func(addr *uintptr) (val uintptr)
sync/atomic.LoadPointer
::
func(addr *unsafe.Pointer) (val unsafe.Pointer)
sync/atomic.StoreInt32
::
func(addr *int32, val int32)
sync/atomic.StoreInt64
::
func(addr *int64, val int64)
sync/atomic.StoreUint32
::
func(addr *uint32, val uint32)
sync/atomic.StoreUint64
::
func(addr *uint64, val uint64)
sync/atomic.StoreUintptr
::
func(addr *uintptr, val uintptr)
sync/atomic.StorePointer
::
func(addr *unsafe.Pointer, val unsafe.Pointer)
sync.NewCond
::
func(l sync.Locker) *sync.Cond
sync.OnceFunc
::
func(f func()) func()
sync.OnceValue
::
func[T any](f func() T) func() T
sync.OnceValues
::
func[T1, T2 any](f func() (T1, T2)) func() (T1, T2)
unicode.IsDigit
::
func(r rune) bool
unicode.IsGraphic
::
func(r rune) bool
unicode.IsPrint
::
func(r rune) bool
unicode.IsOneOf
::
func(ranges []*unicode.RangeTable, r rune) bool
unicode.In
::
func(r rune, ranges ...*unicode.RangeTable) bool
unicode.IsControl
::
func(r rune) bool
unicode.IsLetter
::
func(r rune) bool
unicode.IsMark
::
func(r rune) bool
unicode.IsNumber
::
func(r rune) bool
unicode.IsPunct
::
func(r rune) bool
unicode.IsSpace
::
func(r rune) bool
unicode.IsSymbol
::
func(r rune) bool
unicode.Is
::
func(rangeTab *unicode.RangeTable, r rune) bool
unicode.IsUpper
::
func(r rune) bool
unicode.IsLower
::
func(r rune) bool
unicode.IsTitle
::
func(r rune) bool
unicode.To
::
func(_case int, r rune) rune
unicode.ToUpper
::
func(r rune) rune
unicode.ToLower
::
func(r rune) rune
unicode.ToTitle
::
func(r rune) rune
unicode.SimpleFold
::
func(r rune) rune
reflect.DeepEqual
::
func(x any, y any) bool
reflect.MakeFunc
::
func(typ reflect.Type, fn func(args []reflect.Value) (results []reflect.Value)) reflect.Value
reflect.Swapper
::
func(slice any) func(i int, j int)
reflect.TypeOf
::
func(i any) reflect.Type
reflect.PtrTo
::
func(t reflect.Type) reflect.Type
reflect.PointerTo
::
func(t reflect.Type) reflect.Type
reflect.ChanOf
::
func(dir reflect.ChanDir, t reflect.Type) reflect.Type
reflect.MapOf
::
func(key reflect.Type, elem reflect.Type) reflect.Type
reflect.FuncOf
::
func(in []reflect.Type, out []reflect.Type, variadic bool) reflect.Type
reflect.SliceOf
::
func(t reflect.Type) reflect.Type
reflect.StructOf
::
func(fields []reflect.StructField) reflect.Type
reflect.ArrayOf
::
func(length int, elem reflect.Type) reflect.Type
reflect.TypeFor
::
func[T any]() reflect.Type
reflect.Append
::
func(s reflect.Value, x ...reflect.Value) reflect.Value
reflect.AppendSlice
::
func(s reflect.Value, t reflect.Value) reflect.Value
reflect.Copy
::
func(dst reflect.Value, src reflect.Value) int
reflect.Select
::
func(cases []reflect.SelectCase) (chosen int, recv reflect.Value, recvOK bool)
reflect.MakeSlice
::
func(typ reflect.Type, len int, cap int) reflect.Value
reflect.MakeChan
::
func(typ reflect.Type, buffer int) reflect.Value
reflect.MakeMap
::
func(typ reflect.Type) reflect.Value
reflect.MakeMapWithSize
::
func(typ reflect.Type, n int) reflect.Value
reflect.Indirect
::
func(v reflect.Value) reflect.Value
reflect.ValueOf
::
func(i any) reflect.Value
reflect.Zero
::
func(typ reflect.Type) reflect.Value
reflect.New
::
func(typ reflect.Type) reflect.Value
reflect.NewAt
::
func(typ reflect.Type, p unsafe.Pointer) reflect.Value
reflect.VisibleFields
::
func(t reflect.Type) []reflect.StructField
cmp.Less
::
func[T cmp.Ordered](x T, y T) bool
cmp.Compare
::
func[T cmp.Ordered](x T, y T) int
cmp.Or
::
func[T comparable](vals ...T) T
slices.Equal
::
func[S ~[]E, E comparable](s1 S, s2 S) bool
slices.EqualFunc
::
func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool
slices.Compare
::
func[S ~[]E, E cmp.Ordered](s1 S, s2 S) int
slices.CompareFunc
::
func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int
slices.Index
::
func[S ~[]E, E comparable](s S, v E) int
slices.IndexFunc
::
func[S ~[]E, E any](s S, f func(E) bool) int
slices.Contains
::
func[S ~[]E, E comparable](s S, v E) bool
slices.ContainsFunc
::
func[S ~[]E, E any](s S, f func(E) bool) bool
slices.Insert
::
func[S ~[]E, E any](s S, i int, v ...E) S
slices.Delete
::
func[S ~[]E, E any](s S, i int, j int) S
slices.DeleteFunc
::
func[S ~[]E, E any](s S, del func(E) bool) S
slices.Replace
::
func[S ~[]E, E any](s S, i int, j int, v ...E) S
slices.Clone
::
func[S ~[]E, E any](s S) S
slices.Compact
::
func[S ~[]E, E comparable](s S) S
slices.CompactFunc
::
func[S ~[]E, E any](s S, eq func(E, E) bool) S
slices.Grow
::
func[S ~[]E, E any](s S, n int) S
slices.Clip
::
func[S ~[]E, E any](s S) S
slices.Reverse
::
func[S ~[]E, E any](s S)
slices.Concat
::
func[S ~[]E, E any](slices ...S) S
slices.Sort
::
func[S ~[]E, E cmp.Ordered](x S)
slices.SortFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int)
slices.SortStableFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int)
slices.IsSorted
::
func[S ~[]E, E cmp.Ordered](x S) bool
slices.IsSortedFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int) bool
slices.Min
::
func[S ~[]E, E cmp.Ordered](x S) E
slices.MinFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int) E
slices.Max
::
func[S ~[]E, E cmp.Ordered](x S) E
slices.MaxFunc
::
func[S ~[]E, E any](x S, cmp func(a E, b E) int) E
slices.BinarySearch
::
func[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)
slices.BinarySearchFunc
::
func[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)
sort.Search
::
func(n int, f func(int) bool) int
sort.Find
::
func(n int, cmp func(int) int) (i int, found bool)
sort.SearchInts
::
func(a []int, x int) int
sort.SearchFloat64s
::
func(a []float64, x float64) int
sort.SearchStrings
::
func(a []string, x string) int
sort.Slice
::
func(x any, less func(i int, j int) bool)
sort.SliceStable
::
func(x any, less func(i int, j int) bool)
sort.SliceIsSorted
::
func(x any, less func(i int, j int) bool) bool
sort.Sort
::
func(data sort.Interface)
sort.Reverse
::
func(data sort.Interface) sort.Interface
sort.IsSorted
::
func(data sort.Interface) bool
sort.Ints
::
func(x []int)
sort.Float64s
::
func(x []float64)
sort.Strings
::
func(x []string)
sort.IntsAreSorted
::
func(x []int) bool
sort.Float64sAreSorted
::
func(x []float64) bool
sort.StringsAreSorted
::
func(x []string) bool
sort.Stable
::
func(data sort.Interface)
internal/fmtsort.Sort
::
func(mapValue reflect.Value) *internal/fmtsort.SortedMap
io.WriteString
::
func(w io.Writer, s string) (n int, err error)
io.ReadAtLeast
::
func(r io.Reader, buf []byte, min int) (n int, err error)
io.ReadFull
::
func(r io.Reader, buf []byte) (n int, err error)
io.CopyN
::
func(dst io.Writer, src io.Reader, n int64) (written int64, err error)
io.Copy
::
func(dst io.Writer, src io.Reader) (written int64, err error)
io.CopyBuffer
::
func(dst io.Writer, src io.Reader, buf []byte) (written int64, err error)
io.LimitReader
::
func(r io.Reader, n int64) io.Reader
io.NewSectionReader
::
func(r io.ReaderAt, off int64, n int64) *io.SectionReader
io.NewOffsetWriter
::
func(w io.WriterAt, off int64) *io.OffsetWriter
io.TeeReader
::
func(r io.Reader, w io.Writer) io.Reader
io.NopCloser
::
func(r io.Reader) io.ReadCloser
io.ReadAll
::
func(r io.Reader) ([]byte, error)
io.MultiReader
::
func(readers ...io.Reader) io.Reader
io.MultiWriter
::
func(writers ...io.Writer) io.Writer
io.Pipe
::
func() (*io.PipeReader, *io.PipeWriter)
syscall.ParseDirent
::
func(buf []byte, max int, names []string) (consumed int, count int, newnames []string)
syscall.Unsetenv
::
func(key string) error
syscall.Getenv
::
func(key string) (value string, found bool)
syscall.Setenv
::
func(key string, value string) error
syscall.Clearenv
::
func()
syscall.Environ
::
func() []string
syscall.StringSlicePtr
::
func(ss []string) []*byte
syscall.SlicePtrFromStrings
::
func(ss []string) ([]*byte, error)
syscall.CloseOnExec
::
func(fd int)
syscall.SetNonblock
::
func(fd int, nonblocking bool) (err error)
syscall.ForkExec
::
func(argv0 string, argv []string, attr *syscall.ProcAttr) (pid int, err error)
syscall.StartProcess
::
func(argv0 string, argv []string, attr *syscall.ProcAttr) (pid int, handle uintptr, err error)
syscall.Exec
::
func(argv0 string, argv []string, envv []string) (err error)
syscall.FcntlFlock
::
func(fd uintptr, cmd int, lk *syscall.Flock_t) error
syscall.LsfStmt
::
func(code int, k int) *syscall.SockFilter
syscall.LsfJump
::
func(code int, k int, jt int, jf int) *syscall.SockFilter
syscall.LsfSocket
::
func(ifindex int, proto int) (int, error)
syscall.SetLsfPromisc
::
func(name string, m bool) error
syscall.AttachLsf
::
func(fd int, i []syscall.SockFilter) error
syscall.DetachLsf
::
func(fd int) error
syscall.NetlinkRIB
::
func(proto int, family int) ([]byte, error)
syscall.ParseNetlinkMessage
::
func(b []byte) ([]syscall.NetlinkMessage, error)
syscall.ParseNetlinkRouteAttr
::
func(m *syscall.NetlinkMessage) ([]syscall.NetlinkRouteAttr, error)
syscall.Setrlimit
::
func(resource int, rlim *syscall.Rlimit) error
syscall.UnixCredentials
::
func(ucred *syscall.Ucred) []byte
syscall.ParseUnixCredentials
::
func(m *syscall.SocketControlMessage) (*syscall.Ucred, error)
syscall.CmsgLen
::
func(datalen int) int
syscall.CmsgSpace
::
func(datalen int) int
syscall.ParseSocketControlMessage
::
func(b []byte) ([]syscall.SocketControlMessage, error)
syscall.UnixRights
::
func(fds ...int) []byte
syscall.ParseUnixRights
::
func(m *syscall.SocketControlMessage) ([]int, error)
syscall.StringByteSlice
::
func(s string) []byte
syscall.ByteSliceFromString
::
func(s string) ([]byte, error)
syscall.StringBytePtr
::
func(s string) *byte
syscall.BytePtrFromString
::
func(s string) (*byte, error)
syscall.Getpagesize
::
func() int
syscall.Exit
::
func(code int)
syscall.RawSyscall6
::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
syscall.RawSyscall
::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
syscall.Syscall
::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
syscall.Syscall6
::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
syscall.Access
::
func(path string, mode uint32) (err error)
syscall.Chmod
::
func(path string, mode uint32) (err error)
syscall.Chown
::
func(path string, uid int, gid int) (err error)
syscall.Creat
::
func(path string, mode uint32) (fd int, err error)
syscall.EpollCreate
::
func(size int) (fd int, err error)
syscall.Faccessat
::
func(dirfd int, path string, mode uint32, flags int) (err error)
syscall.Fchmodat
::
func(dirfd int, path string, mode uint32, flags int) error
syscall.Link
::
func(oldpath string, newpath string) (err error)
syscall.Mkdir
::
func(path string, mode uint32) (err error)
syscall.Mknod
::
func(path string, mode uint32, dev int) (err error)
syscall.Open
::
func(path string, mode int, perm uint32) (fd int, err error)
syscall.Openat
::
func(dirfd int, path string, flags int, mode uint32) (fd int, err error)
syscall.Pipe
::
func(p []int) error
syscall.Pipe2
::
func(p []int, flags int) error
syscall.Readlink
::
func(path string, buf []byte) (n int, err error)
syscall.Rename
::
func(oldpath string, newpath string) (err error)
syscall.Rmdir
::
func(path string) error
syscall.Symlink
::
func(oldpath string, newpath string) (err error)
syscall.Unlink
::
func(path string) error
syscall.Unlinkat
::
func(dirfd int, path string) error
syscall.Utimes
::
func(path string, tv []syscall.Timeval) (err error)
syscall.UtimesNano
::
func(path string, ts []syscall.Timespec) (err error)
syscall.Futimesat
::
func(dirfd int, path string, tv []syscall.Timeval) (err error)
syscall.Futimes
::
func(fd int, tv []syscall.Timeval) (err error)
syscall.Getwd
::
func() (wd string, err error)
syscall.Getgroups
::
func() (gids []int, err error)
syscall.Setgroups
::
func(gids []int) (err error)
syscall.Wait4
::
func(pid int, wstatus *syscall.WaitStatus, options int, rusage *syscall.Rusage) (wpid int, err error)
syscall.Mkfifo
::
func(path string, mode uint32) (err error)
syscall.Accept4
::
func(fd int, flags int) (nfd int, sa syscall.Sockaddr, err error)
syscall.Getsockname
::
func(fd int) (sa syscall.Sockaddr, err error)
syscall.GetsockoptInet4Addr
::
func(fd int, level int, opt int) (value [4]byte, err error)
syscall.GetsockoptIPMreq
::
func(fd int, level int, opt int) (*syscall.IPMreq, error)
syscall.GetsockoptIPMreqn
::
func(fd int, level int, opt int) (*syscall.IPMreqn, error)
syscall.GetsockoptIPv6Mreq
::
func(fd int, level int, opt int) (*syscall.IPv6Mreq, error)
syscall.GetsockoptIPv6MTUInfo
::
func(fd int, level int, opt int) (*syscall.IPv6MTUInfo, error)
syscall.GetsockoptICMPv6Filter
::
func(fd int, level int, opt int) (*syscall.ICMPv6Filter, error)
syscall.GetsockoptUcred
::
func(fd int, level int, opt int) (*syscall.Ucred, error)
syscall.SetsockoptIPMreqn
::
func(fd int, level int, opt int, mreq *syscall.IPMreqn) (err error)
syscall.BindToDevice
::
func(fd int, device string) (err error)
syscall.PtracePeekText
::
func(pid int, addr uintptr, out []byte) (count int, err error)
syscall.PtracePeekData
::
func(pid int, addr uintptr, out []byte) (count int, err error)
syscall.PtracePokeText
::
func(pid int, addr uintptr, data []byte) (count int, err error)
syscall.PtracePokeData
::
func(pid int, addr uintptr, data []byte) (count int, err error)
syscall.PtraceGetRegs
::
func(pid int, regsout *syscall.PtraceRegs) (err error)
syscall.PtraceSetRegs
::
func(pid int, regs *syscall.PtraceRegs) (err error)
syscall.PtraceSetOptions
::
func(pid int, options int) (err error)
syscall.PtraceGetEventMsg
::
func(pid int) (msg uint, err error)
syscall.PtraceCont
::
func(pid int, signal int) (err error)
syscall.PtraceSyscall
::
func(pid int, signal int) (err error)
syscall.PtraceSingleStep
::
func(pid int) (err error)
syscall.PtraceAttach
::
func(pid int) (err error)
syscall.PtraceDetach
::
func(pid int) (err error)
syscall.Reboot
::
func(cmd int) (err error)
syscall.ReadDirent
::
func(fd int, buf []byte) (n int, err error)
syscall.Mount
::
func(source string, target string, fstype string, flags uintptr, data string) (err error)
syscall.Getpgrp
::
func() (pid int)
syscall.AllThreadsSyscall
::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
syscall.AllThreadsSyscall6
::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
syscall.Setegid
::
func(egid int) (err error)
syscall.Seteuid
::
func(euid int) (err error)
syscall.Setgid
::
func(gid int) (err error)
syscall.Setregid
::
func(rgid int, egid int) (err error)
syscall.Setresgid
::
func(rgid int, egid int, sgid int) (err error)
syscall.Setresuid
::
func(ruid int, euid int, suid int) (err error)
syscall.Setreuid
::
func(ruid int, euid int) (err error)
syscall.Setuid
::
func(uid int) (err error)
syscall.Mmap
::
func(fd int, offset int64, length int, prot int, flags int) (data []byte, err error)
syscall.Munmap
::
func(b []byte) (err error)
syscall.Accept
::
func(fd int) (nfd int, sa syscall.Sockaddr, err error)
syscall.Stat
::
func(path string, stat *syscall.Stat_t) (err error)
syscall.Lchown
::
func(path string, uid int, gid int) (err error)
syscall.Lstat
::
func(path string, stat *syscall.Stat_t) (err error)
syscall.Gettimeofday
::
func(tv *syscall.Timeval) (err error)
syscall.Time
::
func(t *syscall.Time_t) (tt syscall.Time_t, err error)
syscall.Read
::
func(fd int, p []byte) (n int, err error)
syscall.Write
::
func(fd int, p []byte) (n int, err error)
syscall.Pread
::
func(fd int, p []byte, offset int64) (n int, err error)
syscall.Pwrite
::
func(fd int, p []byte, offset int64) (n int, err error)
syscall.Bind
::
func(fd int, sa syscall.Sockaddr) (err error)
syscall.Connect
::
func(fd int, sa syscall.Sockaddr) (err error)
syscall.Getpeername
::
func(fd int) (sa syscall.Sockaddr, err error)
syscall.GetsockoptInt
::
func(fd int, level int, opt int) (value int, err error)
syscall.Recvfrom
::
func(fd int, p []byte, flags int) (n int, from syscall.Sockaddr, err error)
syscall.Recvmsg
::
func(fd int, p []byte, oob []byte, flags int) (n int, oobn int, recvflags int, from syscall.Sockaddr, err error)
syscall.Sendmsg
::
func(fd int, p []byte, oob []byte, to syscall.Sockaddr, flags int) (err error)
syscall.SendmsgN
::
func(fd int, p []byte, oob []byte, to syscall.Sockaddr, flags int) (n int, err error)
syscall.Sendto
::
func(fd int, p []byte, flags int, to syscall.Sockaddr) (err error)
syscall.SetsockoptByte
::
func(fd int, level int, opt int, value byte) (err error)
syscall.SetsockoptInt
::
func(fd int, level int, opt int, value int) (err error)
syscall.SetsockoptInet4Addr
::
func(fd int, level int, opt int, value [4]byte) (err error)
syscall.SetsockoptIPMreq
::
func(fd int, level int, opt int, mreq *syscall.IPMreq) (err error)
syscall.SetsockoptIPv6Mreq
::
func(fd int, level int, opt int, mreq *syscall.IPv6Mreq) (err error)
syscall.SetsockoptICMPv6Filter
::
func(fd int, level int, opt int, filter *syscall.ICMPv6Filter) error
syscall.SetsockoptLinger
::
func(fd int, level int, opt int, l *syscall.Linger) (err error)
syscall.SetsockoptString
::
func(fd int, level int, opt int, s string) (err error)
syscall.SetsockoptTimeval
::
func(fd int, level int, opt int, tv *syscall.Timeval) (err error)
syscall.Socket
::
func(domain int, typ int, proto int) (fd int, err error)
syscall.Socketpair
::
func(domain int, typ int, proto int) (fd [2]int, err error)
syscall.Sendfile
::
func(outfd int, infd int, offset *int64, count int) (written int, err error)
syscall.TimespecToNsec
::
func(ts syscall.Timespec) int64
syscall.NsecToTimespec
::
func(nsec int64) syscall.Timespec
syscall.TimevalToNsec
::
func(tv syscall.Timeval) int64
syscall.NsecToTimeval
::
func(nsec int64) syscall.Timeval
syscall.Getcwd
::
func(buf []byte) (n int, err error)
syscall.Acct
::
func(path string) (err error)
syscall.Adjtimex
::
func(buf *syscall.Timex) (state int, err error)
syscall.Chdir
::
func(path string) (err error)
syscall.Chroot
::
func(path string) (err error)
syscall.Close
::
func(fd int) (err error)
syscall.Dup
::
func(oldfd int) (fd int, err error)
syscall.Dup3
::
func(oldfd int, newfd int, flags int) (err error)
syscall.EpollCreate1
::
func(flag int) (fd int, err error)
syscall.EpollCtl
::
func(epfd int, op int, fd int, event *syscall.EpollEvent) (err error)
syscall.Fallocate
::
func(fd int, mode uint32, off int64, len int64) (err error)
syscall.Fchdir
::
func(fd int) (err error)
syscall.Fchmod
::
func(fd int, mode uint32) (err error)
syscall.Fchownat
::
func(dirfd int, path string, uid int, gid int, flags int) (err error)
syscall.Fdatasync
::
func(fd int) (err error)
syscall.Flock
::
func(fd int, how int) (err error)
syscall.Fsync
::
func(fd int) (err error)
syscall.Getdents
::
func(fd int, buf []byte) (n int, err error)
syscall.Getpgid
::
func(pid int) (pgid int, err error)
syscall.Getpid
::
func() (pid int)
syscall.Getppid
::
func() (ppid int)
syscall.Getpriority
::
func(which int, who int) (prio int, err error)
syscall.Getrusage
::
func(who int, rusage *syscall.Rusage) (err error)
syscall.Gettid
::
func() (tid int)
syscall.Getxattr
::
func(path string, attr string, dest []byte) (sz int, err error)
syscall.InotifyAddWatch
::
func(fd int, pathname string, mask uint32) (watchdesc int, err error)
syscall.InotifyInit1
::
func(flags int) (fd int, err error)
syscall.InotifyRmWatch
::
func(fd int, watchdesc uint32) (success int, err error)
syscall.Kill
::
func(pid int, sig syscall.Signal) (err error)
syscall.Klogctl
::
func(typ int, buf []byte) (n int, err error)
syscall.Listxattr
::
func(path string, dest []byte) (sz int, err error)
syscall.Mkdirat
::
func(dirfd int, path string, mode uint32) (err error)
syscall.Mknodat
::
func(dirfd int, path string, mode uint32, dev int) (err error)
syscall.Nanosleep
::
func(time *syscall.Timespec, leftover *syscall.Timespec) (err error)
syscall.PivotRoot
::
func(newroot string, putold string) (err error)
syscall.Removexattr
::
func(path string, attr string) (err error)
syscall.Setdomainname
::
func(p []byte) (err error)
syscall.Sethostname
::
func(p []byte) (err error)
syscall.Setpgid
::
func(pid int, pgid int) (err error)
syscall.Setsid
::
func() (pid int, err error)
syscall.Settimeofday
::
func(tv *syscall.Timeval) (err error)
syscall.Setpriority
::
func(which int, who int, prio int) (err error)
syscall.Setxattr
::
func(path string, attr string, data []byte, flags int) (err error)
syscall.Sync
::
func()
syscall.Sysinfo
::
func(info *syscall.Sysinfo_t) (err error)
syscall.Tee
::
func(rfd int, wfd int, len int, flags int) (n int64, err error)
syscall.Tgkill
::
func(tgid int, tid int, sig syscall.Signal) (err error)
syscall.Times
::
func(tms *syscall.Tms) (ticks uintptr, err error)
syscall.Umask
::
func(mask int) (oldmask int)
syscall.Uname
::
func(buf *syscall.Utsname) (err error)
syscall.Unmount
::
func(target string, flags int) (err error)
syscall.Unshare
::
func(flags int) (err error)
syscall.Madvise
::
func(b []byte, advice int) (err error)
syscall.Mprotect
::
func(b []byte, prot int) (err error)
syscall.Mlock
::
func(b []byte) (err error)
syscall.Munlock
::
func(b []byte) (err error)
syscall.Mlockall
::
func(flags int) (err error)
syscall.Munlockall
::
func() (err error)
syscall.Dup2
::
func(oldfd int, newfd int) (err error)
syscall.Fchown
::
func(fd int, uid int, gid int) (err error)
syscall.Fstat
::
func(fd int, stat *syscall.Stat_t) (err error)
syscall.Fstatfs
::
func(fd int, buf *syscall.Statfs_t) (err error)
syscall.Ftruncate
::
func(fd int, length int64) (err error)
syscall.Getegid
::
func() (egid int)
syscall.Geteuid
::
func() (euid int)
syscall.Getgid
::
func() (gid int)
syscall.Getrlimit
::
func(resource int, rlim *syscall.Rlimit) (err error)
syscall.Getuid
::
func() (uid int)
syscall.InotifyInit
::
func() (fd int, err error)
syscall.Ioperm
::
func(from int, num int, on int) (err error)
syscall.Iopl
::
func(level int) (err error)
syscall.Listen
::
func(s int, n int) (err error)
syscall.Pause
::
func() (err error)
syscall.Renameat
::
func(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
syscall.Seek
::
func(fd int, offset int64, whence int) (off int64, err error)
syscall.Select
::
func(nfd int, r *syscall.FdSet, w *syscall.FdSet, e *syscall.FdSet, timeout *syscall.Timeval) (n int, err error)
syscall.Setfsgid
::
func(gid int) (err error)
syscall.Setfsuid
::
func(uid int) (err error)
syscall.Shutdown
::
func(fd int, how int) (err error)
syscall.Splice
::
func(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)
syscall.Statfs
::
func(path string, buf *syscall.Statfs_t) (err error)
syscall.SyncFileRange
::
func(fd int, off int64, n int64, flags int) (err error)
syscall.Truncate
::
func(path string, length int64) (err error)
syscall.Ustat
::
func(dev int, ubuf *syscall.Ustat_t) (err error)
syscall.EpollWait
::
func(epfd int, events []syscall.EpollEvent, msec int) (n int, err error)
syscall.Utime
::
func(path string, buf *syscall.Utimbuf) (err error)
internal/syscall/unix.Unlinkat
::
func(dirfd int, path string, flags int) error
internal/syscall/unix.Openat
::
func(dirfd int, path string, flags int, perm uint32) (int, error)
internal/syscall/unix.Fstatat
::
func(dirfd int, path string, stat *syscall.Stat_t, flags int) error
internal/syscall/unix.CopyFileRange
::
func(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
internal/syscall/unix.Eaccess
::
func(path string, mode uint32) error
internal/syscall/unix.Fcntl
::
func(fd int, cmd int, arg int) (int, error)
internal/syscall/unix.GetRandom
::
func(p []byte, flags internal/syscall/unix.GetRandomFlag) (n int, err error)
internal/syscall/unix.KernelVersion
::
func() (major int, minor int)
internal/syscall/unix.RecvfromInet4
::
func(fd int, p []byte, flags int, from *syscall.SockaddrInet4) (int, error)
internal/syscall/unix.RecvfromInet6
::
func(fd int, p []byte, flags int, from *syscall.SockaddrInet6) (n int, err error)
internal/syscall/unix.SendtoInet4
::
func(fd int, p []byte, flags int, to *syscall.SockaddrInet4) (err error)
internal/syscall/unix.SendtoInet6
::
func(fd int, p []byte, flags int, to *syscall.SockaddrInet6) (err error)
internal/syscall/unix.SendmsgNInet4
::
func(fd int, p []byte, oob []byte, to *syscall.SockaddrInet4, flags int) (n int, err error)
internal/syscall/unix.SendmsgNInet6
::
func(fd int, p []byte, oob []byte, to *syscall.SockaddrInet6, flags int) (n int, err error)
internal/syscall/unix.RecvmsgInet4
::
func(fd int, p []byte, oob []byte, flags int, from *syscall.SockaddrInet4) (n int, oobn int, recvflags int, err error)
internal/syscall/unix.RecvmsgInet6
::
func(fd int, p []byte, oob []byte, flags int, from *syscall.SockaddrInet6) (n int, oobn int, recvflags int, err error)
internal/syscall/unix.IsNonblock
::
func(fd int) (nonblocking bool, err error)
internal/syscall/unix.HasNonblockFlag
::
func(flag int) bool
internal/syscall/unix.PidFDSendSignal
::
func(pidfd uintptr, s syscall.Signal) error
time.Parse
::
func(layout string, value string) (time.Time, error)
time.ParseInLocation
::
func(layout string, value string, loc *time.Location) (time.Time, error)
time.ParseDuration
::
func(s string) (time.Duration, error)
time.Sleep
::
func(d time.Duration)
time.NewTimer
::
func(d time.Duration) *time.Timer
time.After
::
func(d time.Duration) <-chan time.Time
time.AfterFunc
::
func(d time.Duration, f func()) *time.Timer
time.NewTicker
::
func(d time.Duration) *time.Ticker
time.Tick
::
func(d time.Duration) <-chan time.Time
time.Since
::
func(t time.Time) time.Duration
time.Until
::
func(t time.Time) time.Duration
time.Now
::
func() time.Time
time.Unix
::
func(sec int64, nsec int64) time.Time
time.UnixMilli
::
func(msec int64) time.Time
time.UnixMicro
::
func(usec int64) time.Time
time.Date
::
func(year int, month time.Month, day int, hour int, min int, sec int, nsec int, loc *time.Location) time.Time
time.FixedZone
::
func(name string, offset int) *time.Location
time.LoadLocation
::
func(name string) (*time.Location, error)
time.LoadLocationFromTZData
::
func(name string, data []byte) (*time.Location, error)
internal/poll.CopyFileRange
::
func(dst *internal/poll.FD, src *internal/poll.FD, remain int64) (written int64, handled bool, err error)
internal/poll.IsPollDescriptor
::
func(fd uintptr) bool
internal/poll.DupCloseOnExec
::
func(fd int) (int, string, error)
internal/poll.SendFile
::
func(dstFD *internal/poll.FD, src int, remain int64) (int64, error, bool)
internal/poll.Splice
::
func(dst *internal/poll.FD, src *internal/poll.FD, remain int64) (written int64, handled bool, sc string, err error)
internal/safefilepath.FromFS
::
func(path string) (string, error)
internal/syscall/execenv.Default
::
func(sys *syscall.SysProcAttr) ([]string, error)
internal/testlog.PanicOnExit0
::
func() bool
internal/testlog.SetPanicOnExit0
::
func(v bool)
internal/testlog.SetLogger
::
func(impl internal/testlog.Interface)
internal/testlog.Logger
::
func() internal/testlog.Interface
internal/testlog.Getenv
::
func(name string)
internal/testlog.Open
::
func(name string)
internal/testlog.Stat
::
func(name string)
path.Match
::
func(pattern string, name string) (matched bool, err error)
path.Clean
::
func(path string) string
path.Split
::
func(path string) (dir string, file string)
path.Join
::
func(elem ...string) string
path.Ext
::
func(path string) string
path.Base
::
func(path string) string
path.IsAbs
::
func(path string) bool
path.Dir
::
func(path string) string
io/fs.FormatFileInfo
::
func(info io/fs.FileInfo) string
io/fs.FormatDirEntry
::
func(dir io/fs.DirEntry) string
io/fs.ValidPath
::
func(name string) bool
io/fs.Glob
::
func(fsys io/fs.FS, pattern string) (matches []string, err error)
io/fs.ReadDir
::
func(fsys io/fs.FS, name string) ([]io/fs.DirEntry, error)
io/fs.FileInfoToDirEntry
::
func(info io/fs.FileInfo) io/fs.DirEntry
io/fs.ReadFile
::
func(fsys io/fs.FS, name string) ([]byte, error)
io/fs.Stat
::
func(fsys io/fs.FS, name string) (io/fs.FileInfo, error)
io/fs.Sub
::
func(fsys io/fs.FS, dir string) (io/fs.FS, error)
io/fs.WalkDir
::
func(fsys io/fs.FS, root string, fn io/fs.WalkDirFunc) error
os.ReadDir
::
func(name string) ([]io/fs.DirEntry, error)
os.Expand
::
func(s string, mapping func(string) string) string
os.ExpandEnv
::
func(s string) string
os.Getenv
::
func(key string) string
os.LookupEnv
::
func(key string) (string, bool)
os.Setenv
::
func(key string, value string) error
os.Unsetenv
::
func(key string) error
os.Clearenv
::
func()
os.Environ
::
func() []string
os.NewSyscallError
::
func(syscall string, err error) error
os.IsExist
::
func(err error) bool
os.IsNotExist
::
func(err error) bool
os.IsPermission
::
func(err error) bool
os.IsTimeout
::
func(err error) bool
os.Getpid
::
func() int
os.Getppid
::
func() int
os.FindProcess
::
func(pid int) (*os.Process, error)
os.StartProcess
::
func(name string, argv []string, attr *os.ProcAttr) (*os.Process, error)
os.Executable
::
func() (string, error)
os.Mkdir
::
func(name string, perm io/fs.FileMode) error
os.Chdir
::
func(dir string) error
os.Open
::
func(name string) (*os.File, error)
os.Create
::
func(name string) (*os.File, error)
os.OpenFile
::
func(name string, flag int, perm io/fs.FileMode) (*os.File, error)
os.Rename
::
func(oldpath string, newpath string) error
os.Readlink
::
func(name string) (string, error)
os.TempDir
::
func() string
os.UserCacheDir
::
func() (string, error)
os.UserConfigDir
::
func() (string, error)
os.UserHomeDir
::
func() (string, error)
os.Chmod
::
func(name string, mode io/fs.FileMode) error
os.DirFS
::
func(dir string) io/fs.FS
os.ReadFile
::
func(name string) ([]byte, error)
os.WriteFile
::
func(name string, data []byte, perm io/fs.FileMode) error
os.Chown
::
func(name string, uid int, gid int) error
os.Lchown
::
func(name string, uid int, gid int) error
os.Chtimes
::
func(name string, atime time.Time, mtime time.Time) error
os.NewFile
::
func(fd uintptr, name string) *os.File
os.Truncate
::
func(name string, size int64) error
os.Remove
::
func(name string) error
os.Link
::
func(oldname string, newname string) error
os.Symlink
::
func(oldname string, newname string) error
os.Getwd
::
func() (dir string, err error)
os.MkdirAll
::
func(path string, perm io/fs.FileMode) error
os.RemoveAll
::
func(path string) error
os.IsPathSeparator
::
func(c uint8) bool
os.Pipe
::
func() (r *os.File, w *os.File, err error)
os.Getuid
::
func() int
os.Geteuid
::
func() int
os.Getgid
::
func() int
os.Getegid
::
func() int
os.Getgroups
::
func() ([]int, error)
os.Exit
::
func(code int)
os.Stat
::
func(name string) (io/fs.FileInfo, error)
os.Lstat
::
func(name string) (io/fs.FileInfo, error)
os.Hostname
::
func() (name string, err error)
os.CreateTemp
::
func(dir string, pattern string) (*os.File, error)
os.MkdirTemp
::
func(dir string, pattern string) (string, error)
os.Getpagesize
::
func() int
os.SameFile
::
func(fi1 io/fs.FileInfo, fi2 io/fs.FileInfo) bool
fmt.Errorf
::
func(format string, a ...any) error
fmt.FormatString
::
func(state fmt.State, verb rune) string
fmt.Fprintf
::
func(w io.Writer, format string, a ...any) (n int, err error)
fmt.Printf
::
func(format string, a ...any) (n int, err error)
fmt.Sprintf
::
func(format string, a ...any) string
fmt.Appendf
::
func(b []byte, format string, a ...any) []byte
fmt.Fprint
::
func(w io.Writer, a ...any) (n int, err error)
fmt.Print
::
func(a ...any) (n int, err error)
fmt.Sprint
::
func(a ...any) string
fmt.Append
::
func(b []byte, a ...any) []byte
fmt.Fprintln
::
func(w io.Writer, a ...any) (n int, err error)
fmt.Println
::
func(a ...any) (n int, err error)
fmt.Sprintln
::
func(a ...any) string
fmt.Appendln
::
func(b []byte, a ...any) []byte
fmt.Scan
::
func(a ...any) (n int, err error)
fmt.Scanln
::
func(a ...any) (n int, err error)
fmt.Scanf
::
func(format string, a ...any) (n int, err error)
fmt.Sscan
::
func(str string, a ...any) (n int, err error)
fmt.Sscanln
::
func(str string, a ...any) (n int, err error)
fmt.Sscanf
::
func(str string, format string, a ...any) (n int, err error)
fmt.Fscan
::
func(r io.Reader, a ...any) (n int, err error)
fmt.Fscanln
::
func(r io.Reader, a ...any) (n int, err error)
fmt.Fscanf
::
func(r io.Reader, format string, a ...any) (n int, err error)
internal/bisect.New
::
func(pattern string) (*internal/bisect.Matcher, error)
internal/bisect.PrintMarker
::
func(w internal/bisect.Writer, h uint64) error
internal/bisect.Marker
::
func(id uint64) string
internal/bisect.AppendMarker
::
func(dst []byte, id uint64) []byte
internal/bisect.CutMarker
::
func(line string) (short string, id uint64, ok bool)
internal/bisect.Hash
::
func(data ...any) uint64
internal/godebug.New
::
func(name string) *internal/godebug.Setting
math/rand.NewSource
::
func(seed int64) math/rand.Source
math/rand.New
::
func(src math/rand.Source) *math/rand.Rand
math/rand.Seed
::
func(seed int64)
math/rand.Int63
::
func() int64
math/rand.Uint32
::
func() uint32
math/rand.Uint64
::
func() uint64
math/rand.Int31
::
func() int32
math/rand.Int
::
func() int
math/rand.Int63n
::
func(n int64) int64
math/rand.Int31n
::
func(n int32) int32
math/rand.Intn
::
func(n int) int
math/rand.Float64
::
func() float64
math/rand.Float32
::
func() float32
math/rand.Perm
::
func(n int) []int
math/rand.Shuffle
::
func(n int, swap func(i int, j int))
math/rand.Read
::
func(p []byte) (n int, err error)
math/rand.NormFloat64
::
func() float64
math/rand.ExpFloat64
::
func() float64
math/rand.NewZipf
::
func(r *math/rand.Rand, s float64, v float64, imax uint64) *math/rand.Zipf
strings.Clone
::
func(s string) string
strings.Compare
::
func(a string, b string) int
strings.NewReader
::
func(s string) *strings.Reader
strings.NewReplacer
::
func(oldnew ...string) *strings.Replacer
strings.Count
::
func(s string, substr string) int
strings.Contains
::
func(s string, substr string) bool
strings.ContainsAny
::
func(s string, chars string) bool
strings.ContainsRune
::
func(s string, r rune) bool
strings.ContainsFunc
::
func(s string, f func(rune) bool) bool
strings.LastIndex
::
func(s string, substr string) int
strings.IndexByte
::
func(s string, c byte) int
strings.IndexRune
::
func(s string, r rune) int
strings.IndexAny
::
func(s string, chars string) int
strings.LastIndexAny
::
func(s string, chars string) int
strings.LastIndexByte
::
func(s string, c byte) int
strings.SplitN
::
func(s string, sep string, n int) []string
strings.SplitAfterN
::
func(s string, sep string, n int) []string
strings.Split
::
func(s string, sep string) []string
strings.SplitAfter
::
func(s string, sep string) []string
strings.Fields
::
func(s string) []string
strings.FieldsFunc
::
func(s string, f func(rune) bool) []string
strings.Join
::
func(elems []string, sep string) string
strings.HasPrefix
::
func(s string, prefix string) bool
strings.HasSuffix
::
func(s string, suffix string) bool
strings.Map
::
func(mapping func(rune) rune, s string) string
strings.Repeat
::
func(s string, count int) string
strings.ToUpper
::
func(s string) string
strings.ToLower
::
func(s string) string
strings.ToTitle
::
func(s string) string
strings.ToUpperSpecial
::
func(c unicode.SpecialCase, s string) string
strings.ToLowerSpecial
::
func(c unicode.SpecialCase, s string) string
strings.ToTitleSpecial
::
func(c unicode.SpecialCase, s string) string
strings.ToValidUTF8
::
func(s string, replacement string) string
strings.Title
::
func(s string) string
strings.TrimLeftFunc
::
func(s string, f func(rune) bool) string
strings.TrimRightFunc
::
func(s string, f func(rune) bool) string
strings.TrimFunc
::
func(s string, f func(rune) bool) string
strings.IndexFunc
::
func(s string, f func(rune) bool) int
strings.LastIndexFunc
::
func(s string, f func(rune) bool) int
strings.Trim
::
func(s string, cutset string) string
strings.TrimLeft
::
func(s string, cutset string) string
strings.TrimRight
::
func(s string, cutset string) string
strings.TrimSpace
::
func(s string) string
strings.TrimPrefix
::
func(s string, prefix string) string
strings.TrimSuffix
::
func(s string, suffix string) string
strings.Replace
::
func(s string, old string, new string, n int) string
strings.ReplaceAll
::
func(s string, old string, new string) string
strings.EqualFold
::
func(s string, t string) bool
strings.Index
::
func(s string, substr string) int
strings.Cut
::
func(s string, sep string) (before string, after string, found bool)
strings.CutPrefix
::
func(s string, prefix string) (after string, found bool)
strings.CutSuffix
::
func(s string, suffix string) (before string, found bool)
github.com/samber/lo.ChannelDispatcher
::
func[T any](stream <-chan T, count int, channelBufferCap int, strategy github.com/samber/lo.DispatchingStrategy[T]) []<-chan T
github.com/samber/lo.DispatchingStrategyRoundRobin
::
func[T any](msg T, index uint64, channels []<-chan T) int
github.com/samber/lo.DispatchingStrategyRandom
::
func[T any](msg T, index uint64, channels []<-chan T) int
github.com/samber/lo.DispatchingStrategyWeightedRandom
::
func[T any](weights []int) github.com/samber/lo.DispatchingStrategy[T]
github.com/samber/lo.DispatchingStrategyFirst
::
func[T any](msg T, index uint64, channels []<-chan T) int
github.com/samber/lo.DispatchingStrategyLeast
::
func[T any](msg T, index uint64, channels []<-chan T) int
github.com/samber/lo.DispatchingStrategyMost
::
func[T any](msg T, index uint64, channels []<-chan T) int
github.com/samber/lo.SliceToChannel
::
func[T any](bufferSize int, collection []T) <-chan T
github.com/samber/lo.ChannelToSlice
::
func[T any](ch <-chan T) []T
github.com/samber/lo.Generator
::
func[T any](bufferSize int, generator func(yield func(T))) <-chan T
github.com/samber/lo.Buffer
::
func[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
github.com/samber/lo.Batch
::
func[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool)
github.com/samber/lo.BufferWithTimeout
::
func[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
github.com/samber/lo.BatchWithTimeout
::
func[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool)
github.com/samber/lo.FanIn
::
func[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T
github.com/samber/lo.ChannelMerge
::
func[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T
github.com/samber/lo.FanOut
::
func[T any](count int, channelsBufferCap int, upstream <-chan T) []<-chan T
github.com/samber/lo.Synchronize
::
func(opt ...sync.Locker) *github.com/samber/lo.synchronize
github.com/samber/lo.Async0
::
func(f func()) <-chan struct{}
github.com/samber/lo.Async2
::
func[A, B any](f func() (A, B)) <-chan github.com/samber/lo.Tuple2[A, B]
github.com/samber/lo.Async3
::
func[A, B, C any](f func() (A, B, C)) <-chan github.com/samber/lo.Tuple3[A, B, C]
github.com/samber/lo.Async4
::
func[A, B, C, D any](f func() (A, B, C, D)) <-chan github.com/samber/lo.Tuple4[A, B, C, D]
github.com/samber/lo.Async5
::
func[A, B, C, D, E any](f func() (A, B, C, D, E)) <-chan github.com/samber/lo.Tuple5[A, B, C, D, E]
github.com/samber/lo.Async6
::
func[A, B, C, D, E, F any](f func() (A, B, C, D, E, F)) <-chan github.com/samber/lo.Tuple6[A, B, C, D, E, F]
github.com/samber/lo.Ternary
::
func[T any](condition bool, ifOutput T, elseOutput T) T
github.com/samber/lo.TernaryF
::
func[T any](condition bool, ifFunc func() T, elseFunc func() T) T
github.com/samber/lo.If
::
func[T any](condition bool, result T) *github.com/samber/lo.ifElse[T]
github.com/samber/lo.IfF
::
func[T any](condition bool, resultF func() T) *github.com/samber/lo.ifElse[T]
github.com/samber/lo.Switch
::
func[T comparable, R any](predicate T) *github.com/samber/lo.switchCase[T, R]
github.com/samber/lo.Validate
::
func(ok bool, format string, args ...any) error
github.com/samber/lo.Must
::
func[T any](val T, err any, messageArgs ...interface{}) T
github.com/samber/lo.Must0
::
func(err any, messageArgs ...interface{})
github.com/samber/lo.Must1
::
func[T any](val T, err any, messageArgs ...interface{}) T
github.com/samber/lo.Must2
::
func[T1, T2 any](val1 T1, val2 T2, err any, messageArgs ...interface{}) (T1, T2)
github.com/samber/lo.Must3
::
func[T1, T2, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...interface{}) (T1, T2, T3)
github.com/samber/lo.Must4
::
func[T1, T2, T3, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...interface{}) (T1, T2, T3, T4)
github.com/samber/lo.Must5
::
func[T1, T2, T3, T4, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...interface{}) (T1, T2, T3, T4, T5)
github.com/samber/lo.Must6
::
func[T1, T2, T3, T4, T5, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...interface{}) (T1, T2, T3, T4, T5, T6)
github.com/samber/lo.Try
::
func(callback func() error) (ok bool)
github.com/samber/lo.Try0
::
func(callback func()) bool
github.com/samber/lo.Try1
::
func(callback func() error) bool
github.com/samber/lo.Try2
::
func[T any](callback func() (T, error)) bool
github.com/samber/lo.Try3
::
func[T, R any](callback func() (T, R, error)) bool
github.com/samber/lo.Try4
::
func[T, R, S any](callback func() (T, R, S, error)) bool
github.com/samber/lo.Try5
::
func[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool
github.com/samber/lo.Try6
::
func[T, R, S, Q, U any](callback func() (T, R, S, Q, U, error)) bool
github.com/samber/lo.TryOr
::
func[A any](callback func() (A, error), fallbackA A) (A, bool)
github.com/samber/lo.TryOr1
::
func[A any](callback func() (A, error), fallbackA A) (A, bool)
github.com/samber/lo.TryOr2
::
func[A, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool)
github.com/samber/lo.TryOr3
::
func[A, B, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool)
github.com/samber/lo.TryOr4
::
func[A, B, C, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D) (A, B, C, D, bool)
github.com/samber/lo.TryOr5
::
func[A, B, C, D, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E) (A, B, C, D, E, bool)
github.com/samber/lo.TryOr6
::
func[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E, fallbackF F) (A, B, C, D, E, F, bool)
github.com/samber/lo.TryWithErrorValue
::
func(callback func() error) (errorValue any, ok bool)
github.com/samber/lo.TryCatch
::
func(callback func() error, catch func())
github.com/samber/lo.TryCatchWithErrorValue
::
func(callback func() error, catch func(any))
github.com/samber/lo.ErrorsAs
::
func[T error](err error) (T, bool)
github.com/samber/lo.IndexOf
::
func[T comparable](collection []T, element T) int
github.com/samber/lo.LastIndexOf
::
func[T comparable](collection []T, element T) int
github.com/samber/lo.Find
::
func[T any](collection []T, predicate func(item T) bool) (T, bool)
github.com/samber/lo.FindIndexOf
::
func[T any](collection []T, predicate func(item T) bool) (T, int, bool)
github.com/samber/lo.FindLastIndexOf
::
func[T any](collection []T, predicate func(item T) bool) (T, int, bool)
github.com/samber/lo.FindOrElse
::
func[T any](collection []T, fallback T, predicate func(item T) bool) T
github.com/samber/lo.FindKey
::
func[K, V comparable](object map[K]V, value V) (K, bool)
github.com/samber/lo.FindKeyBy
::
func[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool)
github.com/samber/lo.FindUniques
::
func[T comparable](collection []T) []T
github.com/samber/lo.FindUniquesBy
::
func[T any, U comparable](collection []T, iteratee func(item T) U) []T
github.com/samber/lo.FindDuplicates
::
func[T comparable](collection []T) []T
github.com/samber/lo.FindDuplicatesBy
::
func[T any, U comparable](collection []T, iteratee func(item T) U) []T
github.com/samber/lo.Min
::
func[T golang.org/x/exp/constraints.Ordered](collection []T) T
github.com/samber/lo.MinBy
::
func[T any](collection []T, comparison func(a T, b T) bool) T
github.com/samber/lo.Max
::
func[T golang.org/x/exp/constraints.Ordered](collection []T) T
github.com/samber/lo.MaxBy
::
func[T any](collection []T, comparison func(a T, b T) bool) T
github.com/samber/lo.Last
::
func[T any](collection []T) (T, error)
github.com/samber/lo.Nth
::
func[T any, N golang.org/x/exp/constraints.Integer](collection []T, nth N) (T, error)
github.com/samber/lo.Sample
::
func[T any](collection []T) T
github.com/samber/lo.Samples
::
func[T any](collection []T, count int) []T
github.com/samber/lo.Partial
::
func[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R
github.com/samber/lo.Partial1
::
func[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R
github.com/samber/lo.Partial2
::
func[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R
github.com/samber/lo.Partial3
::
func[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R
github.com/samber/lo.Partial4
::
func[T1, T2, T3, T4, T5, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R
github.com/samber/lo.Partial5
::
func[T1, T2, T3, T4, T5, T6, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R
github.com/samber/lo.Contains
::
func[T comparable](collection []T, element T) bool
github.com/samber/lo.ContainsBy
::
func[T any](collection []T, predicate func(item T) bool) bool
github.com/samber/lo.Every
::
func[T comparable](collection []T, subset []T) bool
github.com/samber/lo.EveryBy
::
func[T any](collection []T, predicate func(item T) bool) bool
github.com/samber/lo.Some
::
func[T comparable](collection []T, subset []T) bool
github.com/samber/lo.SomeBy
::
func[T any](collection []T, predicate func(item T) bool) bool
github.com/samber/lo.None
::
func[T comparable](collection []T, subset []T) bool
github.com/samber/lo.NoneBy
::
func[T any](collection []T, predicate func(item T) bool) bool
github.com/samber/lo.Intersect
::
func[T comparable](list1 []T, list2 []T) []T
github.com/samber/lo.Difference
::
func[T comparable](list1 []T, list2 []T) ([]T, []T)
github.com/samber/lo.Union
::
func[T comparable](lists ...[]T) []T
github.com/samber/lo.Without
::
func[T comparable](collection []T, exclude ...T) []T
github.com/samber/lo.WithoutEmpty
::
func[T comparable](collection []T) []T
github.com/samber/lo.Keys
::
func[K comparable, V any](in map[K]V) []K
github.com/samber/lo.Values
::
func[K comparable, V any](in map[K]V) []V
github.com/samber/lo.ValueOr
::
func[K comparable, V any](in map[K]V, key K, fallback V) V
github.com/samber/lo.PickBy
::
func[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
github.com/samber/lo.PickByKeys
::
func[K comparable, V any](in map[K]V, keys []K) map[K]V
github.com/samber/lo.PickByValues
::
func[K, V comparable](in map[K]V, values []V) map[K]V
github.com/samber/lo.OmitBy
::
func[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) map[K]V
github.com/samber/lo.OmitByKeys
::
func[K comparable, V any](in map[K]V, keys []K) map[K]V
github.com/samber/lo.OmitByValues
::
func[K, V comparable](in map[K]V, values []V) map[K]V
github.com/samber/lo.Entries
::
func[K comparable, V any](in map[K]V) []github.com/samber/lo.Entry[K, V]
github.com/samber/lo.ToPairs
::
func[K comparable, V any](in map[K]V) []github.com/samber/lo.Entry[K, V]
github.com/samber/lo.FromEntries
::
func[K comparable, V any](entries []github.com/samber/lo.Entry[K, V]) map[K]V
github.com/samber/lo.FromPairs
::
func[K comparable, V any](entries []github.com/samber/lo.Entry[K, V]) map[K]V
github.com/samber/lo.Invert
::
func[K, V comparable](in map[K]V) map[V]K
github.com/samber/lo.Assign
::
func[K comparable, V any](maps ...map[K]V) map[K]V
github.com/samber/lo.MapKeys
::
func[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V
github.com/samber/lo.MapValues
::
func[K comparable, V, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R
github.com/samber/lo.MapEntries
::
func[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
github.com/samber/lo.MapToSlice
::
func[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) R) []R
github.com/samber/lo.Range
::
func(elementNum int) []int
github.com/samber/lo.RangeFrom
::
func[T golang.org/x/exp/constraints.Integer | golang.org/x/exp/constraints.Float](start T, elementNum int) []T
github.com/samber/lo.RangeWithSteps
::
func[T golang.org/x/exp/constraints.Integer | golang.org/x/exp/constraints.Float](start T, end T, step T) []T
github.com/samber/lo.Clamp
::
func[T golang.org/x/exp/constraints.Ordered](value T, min T, max T) T
github.com/samber/lo.Sum
::
func[T golang.org/x/exp/constraints.Float | golang.org/x/exp/constraints.Integer | golang.org/x/exp/constraints.Complex](collection []T) T
github.com/samber/lo.SumBy
::
func[T any, R golang.org/x/exp/constraints.Float | golang.org/x/exp/constraints.Integer | golang.org/x/exp/constraints.Complex](collection []T, iteratee func(item T) R) R
github.com/samber/lo.NewDebounce
::
func(duration time.Duration, f ...func()) (func(), func())
github.com/samber/lo.NewDebounceBy
::
func[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T))
github.com/samber/lo.Attempt
::
func(maxIteration int, f func(index int) error) (int, error)
github.com/samber/lo.AttemptWithDelay
::
func(maxIteration int, delay time.Duration, f func(index int, duration time.Duration) error) (int, time.Duration, error)
github.com/samber/lo.AttemptWhile
::
func(maxIteration int, f func(int) (error, bool)) (int, error)
github.com/samber/lo.AttemptWhileWithDelay
::
func(maxIteration int, delay time.Duration, f func(int, time.Duration) (error, bool)) (int, time.Duration, error)
github.com/samber/lo.NewTransaction
::
func[T any]() *github.com/samber/lo.Transaction[T]
github.com/samber/lo.Filter
::
func[V any](collection []V, predicate func(item V, index int) bool) []V
github.com/samber/lo.Map
::
func[T, R any](collection []T, iteratee func(item T, index int) R) []R
github.com/samber/lo.FilterMap
::
func[T, R any](collection []T, callback func(item T, index int) (R, bool)) []R
github.com/samber/lo.FlatMap
::
func[T, R any](collection []T, iteratee func(item T, index int) []R) []R
github.com/samber/lo.Reduce
::
func[T, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
github.com/samber/lo.ReduceRight
::
func[T, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R
github.com/samber/lo.ForEach
::
func[T any](collection []T, iteratee func(item T, index int))
github.com/samber/lo.Times
::
func[T any](count int, iteratee func(index int) T) []T
github.com/samber/lo.Uniq
::
func[T comparable](collection []T) []T
github.com/samber/lo.UniqBy
::
func[T any, U comparable](collection []T, iteratee func(item T) U) []T
github.com/samber/lo.GroupBy
::
func[T any, U comparable](collection []T, iteratee func(item T) U) map[U][]T
github.com/samber/lo.Chunk
::
func[T any](collection []T, size int) [][]T
github.com/samber/lo.PartitionBy
::
func[T any, K comparable](collection []T, iteratee func(item T) K) [][]T
github.com/samber/lo.Flatten
::
func[T any](collection [][]T) []T
github.com/samber/lo.Interleave
::
func[T any](collections ...[]T) []T
github.com/samber/lo.Shuffle
::
func[T any](collection []T) []T
github.com/samber/lo.Reverse
::
func[T any](collection []T) []T
github.com/samber/lo.Fill
::
func[T github.com/samber/lo.Clonable[T]](collection []T, initial T) []T
github.com/samber/lo.Repeat
::
func[T github.com/samber/lo.Clonable[T]](count int, initial T) []T
github.com/samber/lo.RepeatBy
::
func[T any](count int, predicate func(index int) T) []T
github.com/samber/lo.KeyBy
::
func[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V
github.com/samber/lo.Associate
::
func[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
github.com/samber/lo.SliceToMap
::
func[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V
github.com/samber/lo.Drop
::
func[T any](collection []T, n int) []T
github.com/samber/lo.DropRight
::
func[T any](collection []T, n int) []T
github.com/samber/lo.DropWhile
::
func[T any](collection []T, predicate func(item T) bool) []T
github.com/samber/lo.DropRightWhile
::
func[T any](collection []T, predicate func(item T) bool) []T
github.com/samber/lo.Reject
::
func[V any](collection []V, predicate func(item V, index int) bool) []V
github.com/samber/lo.Count
::
func[T comparable](collection []T, value T) (count int)
github.com/samber/lo.CountBy
::
func[T any](collection []T, predicate func(item T) bool) (count int)
github.com/samber/lo.CountValues
::
func[T comparable](collection []T) map[T]int
github.com/samber/lo.CountValuesBy
::
func[T any, U comparable](collection []T, mapper func(item T) U) map[U]int
github.com/samber/lo.Subset
::
func[T any](collection []T, offset int, length uint) []T
github.com/samber/lo.Slice
::
func[T any](collection []T, start int, end int) []T
github.com/samber/lo.Replace
::
func[T comparable](collection []T, old T, new T, n int) []T
github.com/samber/lo.ReplaceAll
::
func[T comparable](collection []T, old T, new T) []T
github.com/samber/lo.Compact
::
func[T comparable](collection []T) []T
github.com/samber/lo.IsSorted
::
func[T golang.org/x/exp/constraints.Ordered](collection []T) bool
github.com/samber/lo.IsSortedByKey
::
func[T any, K golang.org/x/exp/constraints.Ordered](collection []T, iteratee func(item T) K) bool
github.com/samber/lo.RandomString
::
func(size int, charset []rune) string
github.com/samber/lo.Substring
::
func[T ~string](str T, offset int, length uint) T
github.com/samber/lo.ChunkString
::
func[T ~string](str T, size int) []T
github.com/samber/lo.RuneLength
::
func(str string) int
github.com/samber/lo.T2
::
func[A, B any](a A, b B) github.com/samber/lo.Tuple2[A, B]
github.com/samber/lo.T3
::
func[A, B, C any](a A, b B, c C) github.com/samber/lo.Tuple3[A, B, C]
github.com/samber/lo.T4
::
func[A, B, C, D any](a A, b B, c C, d D) github.com/samber/lo.Tuple4[A, B, C, D]
github.com/samber/lo.T5
::
func[A, B, C, D, E any](a A, b B, c C, d D, e E) github.com/samber/lo.Tuple5[A, B, C, D, E]
github.com/samber/lo.T6
::
func[A, B, C, D, E, F any](a A, b B, c C, d D, e E, f F) github.com/samber/lo.Tuple6[A, B, C, D, E, F]
github.com/samber/lo.T7
::
func[A, B, C, D, E, F, G any](a A, b B, c C, d D, e E, f F, g G) github.com/samber/lo.Tuple7[A, B, C, D, E, F, G]
github.com/samber/lo.T8
::
func[A, B, C, D, E, F, G, H any](a A, b B, c C, d D, e E, f F, g G, h H) github.com/samber/lo.Tuple8[A, B, C, D, E, F, G, H]
github.com/samber/lo.T9
::
func[A, B, C, D, E, F, G, H, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) github.com/samber/lo.Tuple9[A, B, C, D, E, F, G, H, I]
github.com/samber/lo.Unpack2
::
func[A, B any](tuple github.com/samber/lo.Tuple2[A, B]) (A, B)
github.com/samber/lo.Unpack3
::
func[A, B, C any](tuple github.com/samber/lo.Tuple3[A, B, C]) (A, B, C)
github.com/samber/lo.Unpack4
::
func[A, B, C, D any](tuple github.com/samber/lo.Tuple4[A, B, C, D]) (A, B, C, D)
github.com/samber/lo.Unpack5
::
func[A, B, C, D, E any](tuple github.com/samber/lo.Tuple5[A, B, C, D, E]) (A, B, C, D, E)
github.com/samber/lo.Unpack6
::
func[A, B, C, D, E, F any](tuple github.com/samber/lo.Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F)
github.com/samber/lo.Unpack7
::
func[A, B, C, D, E, F, G any](tuple github.com/samber/lo.Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G)
github.com/samber/lo.Unpack8
::
func[A, B, C, D, E, F, G, H any](tuple github.com/samber/lo.Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H)
github.com/samber/lo.Unpack9
::
func[A, B, C, D, E, F, G, H, I any](tuple github.com/samber/lo.Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I)
github.com/samber/lo.Zip2
::
func[A, B any](a []A, b []B) []github.com/samber/lo.Tuple2[A, B]
github.com/samber/lo.Zip3
::
func[A, B, C any](a []A, b []B, c []C) []github.com/samber/lo.Tuple3[A, B, C]
github.com/samber/lo.Zip4
::
func[A, B, C, D any](a []A, b []B, c []C, d []D) []github.com/samber/lo.Tuple4[A, B, C, D]
github.com/samber/lo.Zip5
::
func[A, B, C, D, E any](a []A, b []B, c []C, d []D, e []E) []github.com/samber/lo.Tuple5[A, B, C, D, E]
github.com/samber/lo.Zip6
::
func[A, B, C, D, E, F any](a []A, b []B, c []C, d []D, e []E, f []F) []github.com/samber/lo.Tuple6[A, B, C, D, E, F]
github.com/samber/lo.Zip7
::
func[A, B, C, D, E, F, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []github.com/samber/lo.Tuple7[A, B, C, D, E, F, G]
github.com/samber/lo.Zip8
::
func[A, B, C, D, E, F, G, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []github.com/samber/lo.Tuple8[A, B, C, D, E, F, G, H]
github.com/samber/lo.Zip9
::
func[A, B, C, D, E, F, G, H, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []github.com/samber/lo.Tuple9[A, B, C, D, E, F, G, H, I]
github.com/samber/lo.Unzip2
::
func[A, B any](tuples []github.com/samber/lo.Tuple2[A, B]) ([]A, []B)
github.com/samber/lo.Unzip3
::
func[A, B, C any](tuples []github.com/samber/lo.Tuple3[A, B, C]) ([]A, []B, []C)
github.com/samber/lo.Unzip4
::
func[A, B, C, D any](tuples []github.com/samber/lo.Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
github.com/samber/lo.Unzip5
::
func[A, B, C, D, E any](tuples []github.com/samber/lo.Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
github.com/samber/lo.Unzip6
::
func[A, B, C, D, E, F any](tuples []github.com/samber/lo.Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
github.com/samber/lo.Unzip7
::
func[A, B, C, D, E, F, G any](tuples []github.com/samber/lo.Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
github.com/samber/lo.Unzip8
::
func[A, B, C, D, E, F, G, H any](tuples []github.com/samber/lo.Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
github.com/samber/lo.Unzip9
::
func[A, B, C, D, E, F, G, H, I any](tuples []github.com/samber/lo.Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
github.com/samber/lo.ToPtr
::
func[T any](x T) *T
github.com/samber/lo.IsNil
::
func(x any) bool
github.com/samber/lo.EmptyableToPtr
::
func[T any](x T) *T
github.com/samber/lo.FromPtr
::
func[T any](x *T) T
github.com/samber/lo.FromPtrOr
::
func[T any](x *T, fallback T) T
github.com/samber/lo.ToSlicePtr
::
func[T any](collection []T) []*T
github.com/samber/lo.ToAnySlice
::
func[T any](collection []T) []any
github.com/samber/lo.FromAnySlice
::
func[T any](in []any) (out []T, ok bool)
github.com/samber/lo.Empty
::
func[T any]() T
github.com/samber/lo.IsEmpty
::
func[T comparable](v T) bool
github.com/samber/lo.IsNotEmpty
::
func[T comparable](v T) bool
github.com/samber/lo.Coalesce
::
func[T comparable](v ...T) (result T, ok bool)
bytes.NewBuffer
::
func(buf []byte) *bytes.Buffer
bytes.NewBufferString
::
func(s string) *bytes.Buffer
bytes.Equal
::
func(a []byte, b []byte) bool
bytes.Compare
::
func(a []byte, b []byte) int
bytes.Count
::
func(s []byte, sep []byte) int
bytes.Contains
::
func(b []byte, subslice []byte) bool
bytes.ContainsAny
::
func(b []byte, chars string) bool
bytes.ContainsRune
::
func(b []byte, r rune) bool
bytes.ContainsFunc
::
func(b []byte, f func(rune) bool) bool
bytes.IndexByte
::
func(b []byte, c byte) int
bytes.LastIndex
::
func(s []byte, sep []byte) int
bytes.LastIndexByte
::
func(s []byte, c byte) int
bytes.IndexRune
::
func(s []byte, r rune) int
bytes.IndexAny
::
func(s []byte, chars string) int
bytes.LastIndexAny
::
func(s []byte, chars string) int
bytes.SplitN
::
func(s []byte, sep []byte, n int) [][]byte
bytes.SplitAfterN
::
func(s []byte, sep []byte, n int) [][]byte
bytes.Split
::
func(s []byte, sep []byte) [][]byte
bytes.SplitAfter
::
func(s []byte, sep []byte) [][]byte
bytes.Fields
::
func(s []byte) [][]byte
bytes.FieldsFunc
::
func(s []byte, f func(rune) bool) [][]byte
bytes.Join
::
func(s [][]byte, sep []byte) []byte
bytes.HasPrefix
::
func(s []byte, prefix []byte) bool
bytes.HasSuffix
::
func(s []byte, suffix []byte) bool
bytes.Map
::
func(mapping func(r rune) rune, s []byte) []byte
bytes.Repeat
::
func(b []byte, count int) []byte
bytes.ToUpper
::
func(s []byte) []byte
bytes.ToLower
::
func(s []byte) []byte
bytes.ToTitle
::
func(s []byte) []byte
bytes.ToUpperSpecial
::
func(c unicode.SpecialCase, s []byte) []byte
bytes.ToLowerSpecial
::
func(c unicode.SpecialCase, s []byte) []byte
bytes.ToTitleSpecial
::
func(c unicode.SpecialCase, s []byte) []byte
bytes.ToValidUTF8
::
func(s []byte, replacement []byte) []byte
bytes.Title
::
func(s []byte) []byte
bytes.TrimLeftFunc
::
func(s []byte, f func(r rune) bool) []byte
bytes.TrimRightFunc
::
func(s []byte, f func(r rune) bool) []byte
bytes.TrimFunc
::
func(s []byte, f func(r rune) bool) []byte
bytes.TrimPrefix
::
func(s []byte, prefix []byte) []byte
bytes.TrimSuffix
::
func(s []byte, suffix []byte) []byte
bytes.IndexFunc
::
func(s []byte, f func(r rune) bool) int
bytes.LastIndexFunc
::
func(s []byte, f func(r rune) bool) int
bytes.Trim
::
func(s []byte, cutset string) []byte
bytes.TrimLeft
::
func(s []byte, cutset string) []byte
bytes.TrimRight
::
func(s []byte, cutset string) []byte
bytes.TrimSpace
::
func(s []byte) []byte
bytes.Runes
::
func(s []byte) []rune
bytes.Replace
::
func(s []byte, old []byte, new []byte, n int) []byte
bytes.ReplaceAll
::
func(s []byte, old []byte, new []byte) []byte
bytes.EqualFold
::
func(s []byte, t []byte) bool
bytes.Index
::
func(s []byte, sep []byte) int
bytes.Cut
::
func(s []byte, sep []byte) (before []byte, after []byte, found bool)
bytes.Clone
::
func(b []byte) []byte
bytes.CutPrefix
::
func(s []byte, prefix []byte) (after []byte, found bool)
bytes.CutSuffix
::
func(s []byte, suffix []byte) (before []byte, found bool)
bytes.NewReader
::
func(b []byte) *bytes.Reader
bufio.NewReaderSize
::
func(rd io.Reader, size int) *bufio.Reader
bufio.NewReader
::
func(rd io.Reader) *bufio.Reader
bufio.NewWriterSize
::
func(w io.Writer, size int) *bufio.Writer
bufio.NewWriter
::
func(w io.Writer) *bufio.Writer
bufio.NewReadWriter
::
func(r *bufio.Reader, w *bufio.Writer) *bufio.ReadWriter
bufio.NewScanner
::
func(r io.Reader) *bufio.Scanner
bufio.ScanBytes
::
func(data []byte, atEOF bool) (advance int, token []byte, err error)
bufio.ScanRunes
::
func(data []byte, atEOF bool) (advance int, token []byte, err error)
bufio.ScanLines
::
func(data []byte, atEOF bool) (advance int, token []byte, err error)
bufio.ScanWords
::
func(data []byte, atEOF bool) (advance int, token []byte, err error)
os/user.Current
::
func() (*os/user.User, error)
os/user.Lookup
::
func(username string) (*os/user.User, error)
os/user.LookupId
::
func(uid string) (*os/user.User, error)
os/user.LookupGroup
::
func(name string) (*os/user.Group, error)
os/user.LookupGroupId
::
func(gid string) (*os/user.Group, error)
path/filepath.Match
::
func(pattern string, name string) (matched bool, err error)
path/filepath.Glob
::
func(pattern string) (matches []string, err error)
path/filepath.Clean
::
func(path string) string
path/filepath.IsLocal
::
func(path string) bool
path/filepath.ToSlash
::
func(path string) string
path/filepath.FromSlash
::
func(path string) string
path/filepath.SplitList
::
func(path string) []string
path/filepath.Split
::
func(path string) (dir string, file string)
path/filepath.Join
::
func(elem ...string) string
path/filepath.Ext
::
func(path string) string
path/filepath.EvalSymlinks
::
func(path string) (string, error)
path/filepath.Abs
::
func(path string) (string, error)
path/filepath.Rel
::
func(basepath string, targpath string) (string, error)
path/filepath.WalkDir
::
func(root string, fn io/fs.WalkDirFunc) error
path/filepath.Walk
::
func(root string, fn path/filepath.WalkFunc) error
path/filepath.Base
::
func(path string) string
path/filepath.Dir
::
func(path string) string
path/filepath.VolumeName
::
func(path string) string
path/filepath.IsAbs
::
func(path string) bool
path/filepath.HasPrefix
::
func(p string, prefix string) bool
archive/tar.FileInfoHeader
::
func(fi io/fs.FileInfo, link string) (*archive/tar.Header, error)
archive/tar.NewReader
::
func(r io.Reader) *archive/tar.Reader
archive/tar.NewWriter
::
func(w io.Writer) *archive/tar.Writer
compress/flate.NewWriter
::
func(w io.Writer, level int) (*compress/flate.Writer, error)
compress/flate.NewWriterDict
::
func(w io.Writer, level int, dict []byte) (*compress/flate.Writer, error)
compress/flate.NewReader
::
func(r io.Reader) io.ReadCloser
compress/flate.NewReaderDict
::
func(r io.Reader, dict []byte) io.ReadCloser
encoding/binary.Read
::
func(r io.Reader, order encoding/binary.ByteOrder, data any) error
encoding/binary.Write
::
func(w io.Writer, order encoding/binary.ByteOrder, data any) error
encoding/binary.Size
::
func(v any) int
encoding/binary.AppendUvarint
::
func(buf []byte, x uint64) []byte
encoding/binary.PutUvarint
::
func(buf []byte, x uint64) int
encoding/binary.Uvarint
::
func(buf []byte) (uint64, int)
encoding/binary.AppendVarint
::
func(buf []byte, x int64) []byte
encoding/binary.PutVarint
::
func(buf []byte, x int64) int
encoding/binary.Varint
::
func(buf []byte) (int64, int)
encoding/binary.ReadUvarint
::
func(r io.ByteReader) (uint64, error)
encoding/binary.ReadVarint
::
func(r io.ByteReader) (int64, error)
hash/crc32.MakeTable
::
func(poly uint32) *hash/crc32.Table
hash/crc32.New
::
func(tab *hash/crc32.Table) hash.Hash32
hash/crc32.NewIEEE
::
func() hash.Hash32
hash/crc32.Update
::
func(crc uint32, tab *hash/crc32.Table, p []byte) uint32
hash/crc32.Checksum
::
func(data []byte, tab *hash/crc32.Table) uint32
hash/crc32.ChecksumIEEE
::
func(data []byte) uint32
archive/zip.OpenReader
::
func(name string) (*archive/zip.ReadCloser, error)
archive/zip.NewReader
::
func(r io.ReaderAt, size int64) (*archive/zip.Reader, error)
archive/zip.RegisterDecompressor
::
func(method uint16, dcomp archive/zip.Decompressor)
archive/zip.RegisterCompressor
::
func(method uint16, comp archive/zip.Compressor)
archive/zip.FileInfoHeader
::
func(fi io/fs.FileInfo) (*archive/zip.FileHeader, error)
archive/zip.NewWriter
::
func(w io.Writer) *archive/zip.Writer
compress/bzip2.NewReader
::
func(r io.Reader) io.Reader
compress/gzip.NewReader
::
func(r io.Reader) (*compress/gzip.Reader, error)
compress/gzip.NewWriter
::
func(w io.Writer) *compress/gzip.Writer
compress/gzip.NewWriterLevel
::
func(w io.Writer, level int) (*compress/gzip.Writer, error)
compress/lzw.NewReader
::
func(r io.Reader, order compress/lzw.Order, litWidth int) io.ReadCloser
compress/lzw.NewWriter
::
func(w io.Writer, order compress/lzw.Order, litWidth int) io.WriteCloser
hash/adler32.New
::
func() hash.Hash32
hash/adler32.Checksum
::
func(data []byte) uint32
compress/zlib.NewReader
::
func(r io.Reader) (io.ReadCloser, error)
compress/zlib.NewReaderDict
::
func(r io.Reader, dict []byte) (io.ReadCloser, error)
compress/zlib.NewWriter
::
func(w io.Writer) *compress/zlib.Writer
compress/zlib.NewWriterLevel
::
func(w io.Writer, level int) (*compress/zlib.Writer, error)
compress/zlib.NewWriterLevelDict
::
func(w io.Writer, level int, dict []byte) (*compress/zlib.Writer, error)
container/heap.Init
::
func(h container/heap.Interface)
container/heap.Push
::
func(h container/heap.Interface, x any)
container/heap.Pop
::
func(h container/heap.Interface) any
container/heap.Remove
::
func(h container/heap.Interface, i int) any
container/heap.Fix
::
func(h container/heap.Interface, i int)
container/list.New
::
func() *container/list.List
container/ring.New
::
func(n int) *container/ring.Ring
context.Background
::
func() context.Context
context.TODO
::
func() context.Context
context.WithCancel
::
func(parent context.Context) (ctx context.Context, cancel context.CancelFunc)
context.WithCancelCause
::
func(parent context.Context) (ctx context.Context, cancel context.CancelCauseFunc)
context.Cause
::
func(c context.Context) error
context.AfterFunc
::
func(ctx context.Context, f func()) (stop func() bool)
context.WithoutCancel
::
func(parent context.Context) context.Context
context.WithDeadline
::
func(parent context.Context, d time.Time) (context.Context, context.CancelFunc)
context.WithDeadlineCause
::
func(parent context.Context, d time.Time, cause error) (context.Context, context.CancelFunc)
context.WithTimeout
::
func(parent context.Context, timeout time.Duration) (context.Context, context.CancelFunc)
context.WithTimeoutCause
::
func(parent context.Context, timeout time.Duration, cause error) (context.Context, context.CancelFunc)
context.WithValue
::
func(parent context.Context, key any, val any) context.Context
crypto.RegisterHash
::
func(h crypto.Hash, f func() hash.Hash)
crypto/internal/alias.AnyOverlap
::
func(x []byte, y []byte) bool
crypto/internal/alias.InexactOverlap
::
func(x []byte, y []byte) bool
crypto/subtle.ConstantTimeCompare
::
func(x []byte, y []byte) int
crypto/subtle.ConstantTimeSelect
::
func(v int, x int, y int) int
crypto/subtle.ConstantTimeByteEq
::
func(x uint8, y uint8) int
crypto/subtle.ConstantTimeEq
::
func(x int32, y int32) int
crypto/subtle.ConstantTimeCopy
::
func(v int, x []byte, y []byte)
crypto/subtle.ConstantTimeLessOrEq
::
func(x int, y int) int
crypto/subtle.XORBytes
::
func(dst []byte, x []byte, y []byte) int
crypto/cipher.NewCBCEncrypter
::
func(b crypto/cipher.Block, iv []byte) crypto/cipher.BlockMode
crypto/cipher.NewCBCDecrypter
::
func(b crypto/cipher.Block, iv []byte) crypto/cipher.BlockMode
crypto/cipher.NewCFBEncrypter
::
func(block crypto/cipher.Block, iv []byte) crypto/cipher.Stream
crypto/cipher.NewCFBDecrypter
::
func(block crypto/cipher.Block, iv []byte) crypto/cipher.Stream
crypto/cipher.NewCTR
::
func(block crypto/cipher.Block, iv []byte) crypto/cipher.Stream
crypto/cipher.NewGCM
::
func(cipher crypto/cipher.Block) (crypto/cipher.AEAD, error)
crypto/cipher.NewGCMWithNonceSize
::
func(cipher crypto/cipher.Block, size int) (crypto/cipher.AEAD, error)
crypto/cipher.NewGCMWithTagSize
::
func(cipher crypto/cipher.Block, tagSize int) (crypto/cipher.AEAD, error)
crypto/cipher.NewOFB
::
func(b crypto/cipher.Block, iv []byte) crypto/cipher.Stream
crypto/internal/boring/sig.BoringCrypto
::
func()
crypto/internal/boring/sig.FIPSOnly
::
func()
crypto/internal/boring/sig.StandardCrypto
::
func()
crypto/internal/boring.Unreachable
::
func()
crypto/internal/boring.UnreachableExceptTests
::
func()
crypto/internal/boring.NewSHA1
::
func() hash.Hash
crypto/internal/boring.NewSHA224
::
func() hash.Hash
crypto/internal/boring.NewSHA256
::
func() hash.Hash
crypto/internal/boring.NewSHA384
::
func() hash.Hash
crypto/internal/boring.NewSHA512
::
func() hash.Hash
crypto/internal/boring.SHA1
::
func([]byte) [20]byte
crypto/internal/boring.SHA224
::
func([]byte) [28]byte
crypto/internal/boring.SHA256
::
func([]byte) [32]byte
crypto/internal/boring.SHA384
::
func([]byte) [48]byte
crypto/internal/boring.SHA512
::
func([]byte) [64]byte
crypto/internal/boring.NewHMAC
::
func(h func() hash.Hash, key []byte) hash.Hash
crypto/internal/boring.NewAESCipher
::
func(key []byte) (crypto/cipher.Block, error)
crypto/internal/boring.NewGCMTLS
::
func(crypto/cipher.Block) (crypto/cipher.AEAD, error)
crypto/internal/boring.GenerateKeyECDSA
::
func(curve string) (X crypto/internal/boring.BigInt, Y crypto/internal/boring.BigInt, D crypto/internal/boring.BigInt, err error)
crypto/internal/boring.NewPrivateKeyECDSA
::
func(curve string, X crypto/internal/boring.BigInt, Y crypto/internal/boring.BigInt, D crypto/internal/boring.BigInt) (*crypto/internal/boring.PrivateKeyECDSA, error)
crypto/internal/boring.NewPublicKeyECDSA
::
func(curve string, X crypto/internal/boring.BigInt, Y crypto/internal/boring.BigInt) (*crypto/internal/boring.PublicKeyECDSA, error)
crypto/internal/boring.SignMarshalECDSA
::
func(priv *crypto/internal/boring.PrivateKeyECDSA, hash []byte) ([]byte, error)
crypto/internal/boring.VerifyECDSA
::
func(pub *crypto/internal/boring.PublicKeyECDSA, hash []byte, sig []byte) bool
crypto/internal/boring.DecryptRSAOAEP
::
func(h hash.Hash, mgfHash hash.Hash, priv *crypto/internal/boring.PrivateKeyRSA, ciphertext []byte, label []byte) ([]byte, error)
crypto/internal/boring.DecryptRSAPKCS1
::
func(priv *crypto/internal/boring.PrivateKeyRSA, ciphertext []byte) ([]byte, error)
crypto/internal/boring.DecryptRSANoPadding
::
func(priv *crypto/internal/boring.PrivateKeyRSA, ciphertext []byte) ([]byte, error)
crypto/internal/boring.EncryptRSAOAEP
::
func(h hash.Hash, mgfHash hash.Hash, pub *crypto/internal/boring.PublicKeyRSA, msg []byte, label []byte) ([]byte, error)
crypto/internal/boring.EncryptRSAPKCS1
::
func(pub *crypto/internal/boring.PublicKeyRSA, msg []byte) ([]byte, error)
crypto/internal/boring.EncryptRSANoPadding
::
func(pub *crypto/internal/boring.PublicKeyRSA, msg []byte) ([]byte, error)
crypto/internal/boring.GenerateKeyRSA
::
func(bits int) (N crypto/internal/boring.BigInt, E crypto/internal/boring.BigInt, D crypto/internal/boring.BigInt, P crypto/internal/boring.BigInt, Q crypto/internal/boring.BigInt, Dp crypto/internal/boring.BigInt, Dq crypto/internal/boring.BigInt, Qinv crypto/internal/boring.BigInt, err error)
crypto/internal/boring.NewPrivateKeyRSA
::
func(N crypto/internal/boring.BigInt, E crypto/internal/boring.BigInt, D crypto/internal/boring.BigInt, P crypto/internal/boring.BigInt, Q crypto/internal/boring.BigInt, Dp crypto/internal/boring.BigInt, Dq crypto/internal/boring.BigInt, Qinv crypto/internal/boring.BigInt) (*crypto/internal/boring.PrivateKeyRSA, error)
crypto/internal/boring.NewPublicKeyRSA
::
func(N crypto/internal/boring.BigInt, E crypto/internal/boring.BigInt) (*crypto/internal/boring.PublicKeyRSA, error)
crypto/internal/boring.SignRSAPKCS1v15
::
func(priv *crypto/internal/boring.PrivateKeyRSA, h crypto.Hash, hashed []byte) ([]byte, error)
crypto/internal/boring.SignRSAPSS
::
func(priv *crypto/internal/boring.PrivateKeyRSA, h crypto.Hash, hashed []byte, saltLen int) ([]byte, error)
crypto/internal/boring.VerifyRSAPKCS1v15
::
func(pub *crypto/internal/boring.PublicKeyRSA, h crypto.Hash, hashed []byte, sig []byte) error
crypto/internal/boring.VerifyRSAPSS
::
func(pub *crypto/internal/boring.PublicKeyRSA, h crypto.Hash, hashed []byte, sig []byte, saltLen int) error
crypto/internal/boring.ECDH
::
func(*crypto/internal/boring.PrivateKeyECDH, *crypto/internal/boring.PublicKeyECDH) ([]byte, error)
crypto/internal/boring.GenerateKeyECDH
::
func(string) (*crypto/internal/boring.PrivateKeyECDH, []byte, error)
crypto/internal/boring.NewPrivateKeyECDH
::
func(string, []byte) (*crypto/internal/boring.PrivateKeyECDH, error)
crypto/internal/boring.NewPublicKeyECDH
::
func(string, []byte) (*crypto/internal/boring.PublicKeyECDH, error)
crypto/aes.NewCipher
::
func(key []byte) (crypto/cipher.Block, error)
crypto/des.NewCipher
::
func(key []byte) (crypto/cipher.Block, error)
crypto/des.NewTripleDESCipher
::
func(key []byte) (crypto/cipher.Block, error)
crypto/internal/randutil.MaybeReadByte
::
func(r io.Reader)
math/big.NewFloat
::
func(x float64) *math/big.Float
math/big.ParseFloat
::
func(s string, base int, prec uint, mode math/big.RoundingMode) (f *math/big.Float, b int, err error)
math/big.NewInt
::
func(x int64) *math/big.Int
math/big.Jacobi
::
func(x *math/big.Int, y *math/big.Int) int
math/big.NewRat
::
func(a int64, b int64) *math/big.Rat
crypto/dsa.GenerateParameters
::
func(params *crypto/dsa.Parameters, rand io.Reader, sizes crypto/dsa.ParameterSizes) error
crypto/dsa.GenerateKey
::
func(priv *crypto/dsa.PrivateKey, rand io.Reader) error
crypto/dsa.Sign
::
func(rand io.Reader, priv *crypto/dsa.PrivateKey, hash []byte) (r *math/big.Int, s *math/big.Int, err error)
crypto/dsa.Verify
::
func(pub *crypto/dsa.PublicKey, hash []byte, r *math/big.Int, s *math/big.Int) bool
crypto/internal/nistec.NewP224Point
::
func() *crypto/internal/nistec.P224Point
crypto/internal/nistec.NewP256Point
::
func() *crypto/internal/nistec.P256Point
crypto/internal/nistec.P256OrdInverse
::
func(k []byte) ([]byte, error)
crypto/internal/nistec.NewP384Point
::
func() *crypto/internal/nistec.P384Point
crypto/internal/nistec.NewP521Point
::
func() *crypto/internal/nistec.P521Point
crypto/ecdh.P256
::
func() crypto/ecdh.Curve
crypto/ecdh.P384
::
func() crypto/ecdh.Curve
crypto/ecdh.P521
::
func() crypto/ecdh.Curve
crypto/ecdh.X25519
::
func() crypto/ecdh.Curve
crypto/elliptic.GenerateKey
::
func(curve crypto/elliptic.Curve, rand io.Reader) (priv []byte, x *math/big.Int, y *math/big.Int, err error)
crypto/elliptic.Marshal
::
func(curve crypto/elliptic.Curve, x *math/big.Int, y *math/big.Int) []byte
crypto/elliptic.MarshalCompressed
::
func(curve crypto/elliptic.Curve, x *math/big.Int, y *math/big.Int) []byte
crypto/elliptic.Unmarshal
::
func(curve crypto/elliptic.Curve, data []byte) (x *math/big.Int, y *math/big.Int)
crypto/elliptic.UnmarshalCompressed
::
func(curve crypto/elliptic.Curve, data []byte) (x *math/big.Int, y *math/big.Int)
crypto/elliptic.P224
::
func() crypto/elliptic.Curve
crypto/elliptic.P256
::
func() crypto/elliptic.Curve
crypto/elliptic.P384
::
func() crypto/elliptic.Curve
crypto/elliptic.P521
::
func() crypto/elliptic.Curve
crypto/internal/bigmod.NewNat
::
func() *crypto/internal/bigmod.Nat
crypto/internal/bigmod.NewModulusFromBig
::
func(n *math/big.Int) (*crypto/internal/bigmod.Modulus, error)
crypto/internal/boring/bbig.Enc
::
func(b *math/big.Int) crypto/internal/boring.BigInt
crypto/internal/boring/bbig.Dec
::
func(b crypto/internal/boring.BigInt) *math/big.Int
crypto/sha512.New
::
func() hash.Hash
crypto/sha512.New512_224
::
func() hash.Hash
crypto/sha512.New512_256
::
func() hash.Hash
crypto/sha512.New384
::
func() hash.Hash
crypto/sha512.Sum512
::
func(data []byte) [64]byte
crypto/sha512.Sum384
::
func(data []byte) [48]byte
crypto/sha512.Sum512_224
::
func(data []byte) [28]byte
crypto/sha512.Sum512_256
::
func(data []byte) [32]byte
unicode/utf16.IsSurrogate
::
func(r rune) bool
unicode/utf16.DecodeRune
::
func(r1 rune, r2 rune) rune
unicode/utf16.EncodeRune
::
func(r rune) (r1 rune, r2 rune)
unicode/utf16.Encode
::
func(s []rune) []uint16
unicode/utf16.AppendRune
::
func(a []uint16, r rune) []uint16
unicode/utf16.Decode
::
func(s []uint16) []rune
encoding/asn1.Unmarshal
::
func(b []byte, val any) (rest []byte, err error)
encoding/asn1.UnmarshalWithParams
::
func(b []byte, val any, params string) (rest []byte, err error)
encoding/asn1.Marshal
::
func(val any) ([]byte, error)
encoding/asn1.MarshalWithParams
::
func(val any, params string) ([]byte, error)
vendor/golang.org/x/crypto/cryptobyte.NewBuilder
::
func(buffer []byte) *vendor/golang.org/x/crypto/cryptobyte.Builder
vendor/golang.org/x/crypto/cryptobyte.NewFixedBuilder
::
func(buffer []byte) *vendor/golang.org/x/crypto/cryptobyte.Builder
crypto/ecdsa.GenerateKey
::
func(c crypto/elliptic.Curve, rand io.Reader) (*crypto/ecdsa.PrivateKey, error)
crypto/ecdsa.SignASN1
::
func(rand io.Reader, priv *crypto/ecdsa.PrivateKey, hash []byte) ([]byte, error)
crypto/ecdsa.VerifyASN1
::
func(pub *crypto/ecdsa.PublicKey, hash []byte, sig []byte) bool
crypto/ecdsa.Sign
::
func(rand io.Reader, priv *crypto/ecdsa.PrivateKey, hash []byte) (r *math/big.Int, s *math/big.Int, err error)
crypto/ecdsa.Verify
::
func(pub *crypto/ecdsa.PublicKey, hash []byte, r *math/big.Int, s *math/big.Int) bool
crypto/internal/edwards25519.NewIdentityPoint
::
func() *crypto/internal/edwards25519.Point
crypto/internal/edwards25519.NewGeneratorPoint
::
func() *crypto/internal/edwards25519.Point
crypto/internal/edwards25519.NewScalar
::
func() *crypto/internal/edwards25519.Scalar
crypto/rand.Read
::
func(b []byte) (n int, err error)
crypto/rand.Prime
::
func(rand io.Reader, bits int) (*math/big.Int, error)
crypto/rand.Int
::
func(rand io.Reader, max *math/big.Int) (n *math/big.Int, err error)
crypto/ed25519.GenerateKey
::
func(rand io.Reader) (crypto/ed25519.PublicKey, crypto/ed25519.PrivateKey, error)
crypto/ed25519.NewKeyFromSeed
::
func(seed []byte) crypto/ed25519.PrivateKey
crypto/ed25519.Sign
::
func(privateKey crypto/ed25519.PrivateKey, message []byte) []byte
crypto/ed25519.Verify
::
func(publicKey crypto/ed25519.PublicKey, message []byte, sig []byte) bool
crypto/ed25519.VerifyWithOptions
::
func(publicKey crypto/ed25519.PublicKey, message []byte, sig []byte, opts *crypto/ed25519.Options) error
crypto/hmac.New
::
func(h func() hash.Hash, key []byte) hash.Hash
crypto/hmac.Equal
::
func(mac1 []byte, mac2 []byte) bool
crypto/md5.New
::
func() hash.Hash
crypto/md5.Sum
::
func(data []byte) [16]byte
crypto/rc4.NewCipher
::
func(key []byte) (*crypto/rc4.Cipher, error)
crypto/rsa.EncryptPKCS1v15
::
func(random io.Reader, pub *crypto/rsa.PublicKey, msg []byte) ([]byte, error)
crypto/rsa.DecryptPKCS1v15
::
func(random io.Reader, priv *crypto/rsa.PrivateKey, ciphertext []byte) ([]byte, error)
crypto/rsa.DecryptPKCS1v15SessionKey
::
func(random io.Reader, priv *crypto/rsa.PrivateKey, ciphertext []byte, key []byte) error
crypto/rsa.SignPKCS1v15
::
func(random io.Reader, priv *crypto/rsa.PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)
crypto/rsa.VerifyPKCS1v15
::
func(pub *crypto/rsa.PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error
crypto/rsa.SignPSS
::
func(rand io.Reader, priv *crypto/rsa.PrivateKey, hash crypto.Hash, digest []byte, opts *crypto/rsa.PSSOptions) ([]byte, error)
crypto/rsa.VerifyPSS
::
func(pub *crypto/rsa.PublicKey, hash crypto.Hash, digest []byte, sig []byte, opts *crypto/rsa.PSSOptions) error
crypto/rsa.GenerateKey
::
func(random io.Reader, bits int) (*crypto/rsa.PrivateKey, error)
crypto/rsa.GenerateMultiPrimeKey
::
func(random io.Reader, nprimes int, bits int) (*crypto/rsa.PrivateKey, error)
crypto/rsa.EncryptOAEP
::
func(hash hash.Hash, random io.Reader, pub *crypto/rsa.PublicKey, msg []byte, label []byte) ([]byte, error)
crypto/rsa.DecryptOAEP
::
func(hash hash.Hash, random io.Reader, priv *crypto/rsa.PrivateKey, ciphertext []byte, label []byte) ([]byte, error)
crypto/sha1.New
::
func() hash.Hash
crypto/sha1.Sum
::
func(data []byte) [20]byte
crypto/sha256.New
::
func() hash.Hash
crypto/sha256.New224
::
func() hash.Hash
crypto/sha256.Sum256
::
func(data []byte) [32]byte
crypto/sha256.Sum224
::
func(data []byte) [28]byte
encoding/hex.EncodedLen
::
func(n int) int
encoding/hex.Encode
::
func(dst []byte, src []byte) int
encoding/hex.AppendEncode
::
func(dst []byte, src []byte) []byte
encoding/hex.DecodedLen
::
func(x int) int
encoding/hex.Decode
::
func(dst []byte, src []byte) (int, error)
encoding/hex.AppendDecode
::
func(dst []byte, src []byte) ([]byte, error)
encoding/hex.EncodeToString
::
func(src []byte) string
encoding/hex.DecodeString
::
func(s string) ([]byte, error)
encoding/hex.Dump
::
func(data []byte) string
encoding/hex.NewEncoder
::
func(w io.Writer) io.Writer
encoding/hex.NewDecoder
::
func(r io.Reader) io.Reader
encoding/hex.Dumper
::
func(w io.Writer) io.WriteCloser
encoding/base64.NewEncoding
::
func(encoder string) *encoding/base64.Encoding
encoding/base64.NewEncoder
::
func(enc *encoding/base64.Encoding, w io.Writer) io.WriteCloser
encoding/base64.NewDecoder
::
func(enc *encoding/base64.Encoding, r io.Reader) io.Reader
encoding/pem.Decode
::
func(data []byte) (p *encoding/pem.Block, rest []byte)
encoding/pem.Encode
::
func(out io.Writer, b *encoding/pem.Block) error
encoding/pem.EncodeToMemory
::
func(b *encoding/pem.Block) []byte
vendor/golang.org/x/net/dns/dnsmessage.NewBuilder
::
func(buf []byte, h vendor/golang.org/x/net/dns/dnsmessage.Header) vendor/golang.org/x/net/dns/dnsmessage.Builder
vendor/golang.org/x/net/dns/dnsmessage.NewName
::
func(name string) (vendor/golang.org/x/net/dns/dnsmessage.Name, error)
vendor/golang.org/x/net/dns/dnsmessage.MustNewName
::
func(name string) vendor/golang.org/x/net/dns/dnsmessage.Name
internal/intern.Get
::
func(cmpVal any) *internal/intern.Value
internal/intern.GetByString
::
func(s string) *internal/intern.Value
net/netip.IPv6LinkLocalAllNodes
::
func() net/netip.Addr
net/netip.IPv6LinkLocalAllRouters
::
func() net/netip.Addr
net/netip.IPv6Loopback
::
func() net/netip.Addr
net/netip.IPv6Unspecified
::
func() net/netip.Addr
net/netip.IPv4Unspecified
::
func() net/netip.Addr
net/netip.AddrFrom4
::
func(addr [4]byte) net/netip.Addr
net/netip.AddrFrom16
::
func(addr [16]byte) net/netip.Addr
net/netip.ParseAddr
::
func(s string) (net/netip.Addr, error)
net/netip.MustParseAddr
::
func(s string) net/netip.Addr
net/netip.AddrFromSlice
::
func(slice []byte) (ip net/netip.Addr, ok bool)
net/netip.AddrPortFrom
::
func(ip net/netip.Addr, port uint16) net/netip.AddrPort
net/netip.ParseAddrPort
::
func(s string) (net/netip.AddrPort, error)
net/netip.MustParseAddrPort
::
func(s string) net/netip.AddrPort
net/netip.PrefixFrom
::
func(ip net/netip.Addr, bits int) net/netip.Prefix
net/netip.ParsePrefix
::
func(s string) (net/netip.Prefix, error)
net/netip.MustParsePrefix
::
func(s string) net/netip.Prefix
net.Dial
::
func(network string, address string) (net.Conn, error)
net.DialTimeout
::
func(network string, address string, timeout time.Duration) (net.Conn, error)
net.Listen
::
func(network string, address string) (net.Listener, error)
net.ListenPacket
::
func(network string, address string) (net.PacketConn, error)
net.FileConn
::
func(f *os.File) (c net.Conn, err error)
net.FileListener
::
func(f *os.File) (ln net.Listener, err error)
net.FilePacketConn
::
func(f *os.File) (c net.PacketConn, err error)
net.Interfaces
::
func() ([]net.Interface, error)
net.InterfaceAddrs
::
func() ([]net.Addr, error)
net.InterfaceByIndex
::
func(index int) (*net.Interface, error)
net.InterfaceByName
::
func(name string) (*net.Interface, error)
net.IPv4
::
func(a byte, b byte, c byte, d byte) net.IP
net.IPv4Mask
::
func(a byte, b byte, c byte, d byte) net.IPMask
net.CIDRMask
::
func(ones int, bits int) net.IPMask
net.ParseIP
::
func(s string) net.IP
net.ParseCIDR
::
func(s string) (net.IP, *net.IPNet, error)
net.ResolveIPAddr
::
func(network string, address string) (*net.IPAddr, error)
net.DialIP
::
func(network string, laddr *net.IPAddr, raddr *net.IPAddr) (*net.IPConn, error)
net.ListenIP
::
func(network string, laddr *net.IPAddr) (*net.IPConn, error)
net.SplitHostPort
::
func(hostport string) (host string, port string, err error)
net.JoinHostPort
::
func(host string, port string) string
net.LookupHost
::
func(host string) (addrs []string, err error)
net.LookupIP
::
func(host string) ([]net.IP, error)
net.LookupPort
::
func(network string, service string) (port int, err error)
net.LookupCNAME
::
func(host string) (cname string, err error)
net.LookupSRV
::
func(service string, proto string, name string) (cname string, addrs []*net.SRV, err error)
net.LookupMX
::
func(name string) ([]*net.MX, error)
net.LookupNS
::
func(name string) ([]*net.NS, error)
net.LookupTXT
::
func(name string) ([]string, error)
net.LookupAddr
::
func(addr string) (names []string, err error)
net.ParseMAC
::
func(s string) (hw net.HardwareAddr, err error)
net.Pipe
::
func() (net.Conn, net.Conn)
net.ResolveTCPAddr
::
func(network string, address string) (*net.TCPAddr, error)
net.TCPAddrFromAddrPort
::
func(addr net/netip.AddrPort) *net.TCPAddr
net.DialTCP
::
func(network string, laddr *net.TCPAddr, raddr *net.TCPAddr) (*net.TCPConn, error)
net.ListenTCP
::
func(network string, laddr *net.TCPAddr) (*net.TCPListener, error)
net.ResolveUDPAddr
::
func(network string, address string) (*net.UDPAddr, error)
net.UDPAddrFromAddrPort
::
func(addr net/netip.AddrPort) *net.UDPAddr
net.DialUDP
::
func(network string, laddr *net.UDPAddr, raddr *net.UDPAddr) (*net.UDPConn, error)
net.ListenUDP
::
func(network string, laddr *net.UDPAddr) (*net.UDPConn, error)
net.ListenMulticastUDP
::
func(network string, ifi *net.Interface, gaddr *net.UDPAddr) (*net.UDPConn, error)
net.ResolveUnixAddr
::
func(network string, address string) (*net.UnixAddr, error)
net.DialUnix
::
func(network string, laddr *net.UnixAddr, raddr *net.UnixAddr) (*net.UnixConn, error)
net.ListenUnix
::
func(network string, laddr *net.UnixAddr) (*net.UnixListener, error)
net.ListenUnixgram
::
func(network string, laddr *net.UnixAddr) (*net.UnixConn, error)
net/url.QueryUnescape
::
func(s string) (string, error)
net/url.PathUnescape
::
func(s string) (string, error)
net/url.QueryEscape
::
func(s string) string
net/url.PathEscape
::
func(s string) string
net/url.User
::
func(username string) *net/url.Userinfo
net/url.UserPassword
::
func(username string, password string) *net/url.Userinfo
net/url.Parse
::
func(rawURL string) (*net/url.URL, error)
net/url.ParseRequestURI
::
func(rawURL string) (*net/url.URL, error)
net/url.ParseQuery
::
func(query string) (net/url.Values, error)
net/url.JoinPath
::
func(base string, elem ...string) (result string, err error)
crypto/x509.NewCertPool
::
func() *crypto/x509.CertPool
crypto/x509.SystemCertPool
::
func() (*crypto/x509.CertPool, error)
crypto/x509.OIDFromInts
::
func(oid []uint64) (crypto/x509.OID, error)
crypto/x509.ParseCertificate
::
func(der []byte) (*crypto/x509.Certificate, error)
crypto/x509.ParseCertificates
::
func(der []byte) ([]*crypto/x509.Certificate, error)
crypto/x509.ParseRevocationList
::
func(der []byte) (*crypto/x509.RevocationList, error)
crypto/x509.IsEncryptedPEMBlock
::
func(b *encoding/pem.Block) bool
crypto/x509.DecryptPEMBlock
::
func(b *encoding/pem.Block, password []byte) ([]byte, error)
crypto/x509.EncryptPEMBlock
::
func(rand io.Reader, blockType string, data []byte, password []byte, alg crypto/x509.PEMCipher) (*encoding/pem.Block, error)
crypto/x509.ParsePKCS1PrivateKey
::
func(der []byte) (*crypto/rsa.PrivateKey, error)
crypto/x509.MarshalPKCS1PrivateKey
::
func(key *crypto/rsa.PrivateKey) []byte
crypto/x509.ParsePKCS1PublicKey
::
func(der []byte) (*crypto/rsa.PublicKey, error)
crypto/x509.MarshalPKCS1PublicKey
::
func(key *crypto/rsa.PublicKey) []byte
crypto/x509.ParsePKCS8PrivateKey
::
func(der []byte) (key any, err error)
crypto/x509.MarshalPKCS8PrivateKey
::
func(key any) ([]byte, error)
crypto/x509.SetFallbackRoots
::
func(roots *crypto/x509.CertPool)
crypto/x509.ParseECPrivateKey
::
func(der []byte) (*crypto/ecdsa.PrivateKey, error)
crypto/x509.MarshalECPrivateKey
::
func(key *crypto/ecdsa.PrivateKey) ([]byte, error)
crypto/x509.ParsePKIXPublicKey
::
func(derBytes []byte) (pub any, err error)
crypto/x509.MarshalPKIXPublicKey
::
func(pub any) ([]byte, error)
crypto/x509.CreateCertificate
::
func(rand io.Reader, template *crypto/x509.Certificate, parent *crypto/x509.Certificate, pub any, priv any) ([]byte, error)
crypto/x509.ParseCRL
::
func(crlBytes []byte) (*crypto/x509/pkix.CertificateList, error)
crypto/x509.ParseDERCRL
::
func(derBytes []byte) (*crypto/x509/pkix.CertificateList, error)
crypto/x509.CreateCertificateRequest
::
func(rand io.Reader, template *crypto/x509.CertificateRequest, priv any) (csr []byte, err error)
crypto/x509.ParseCertificateRequest
::
func(asn1Data []byte) (*crypto/x509.CertificateRequest, error)
crypto/x509.CreateRevocationList
::
func(rand io.Reader, template *crypto/x509.RevocationList, issuer *crypto/x509.Certificate, priv crypto.Signer) ([]byte, error)
vendor/golang.org/x/crypto/internal/alias.AnyOverlap
::
func(x []byte, y []byte) bool
vendor/golang.org/x/crypto/internal/alias.InexactOverlap
::
func(x []byte, y []byte) bool
vendor/golang.org/x/crypto/chacha20.NewUnauthenticatedCipher
::
func(key []byte, nonce []byte) (*vendor/golang.org/x/crypto/chacha20.Cipher, error)
vendor/golang.org/x/crypto/chacha20.HChaCha20
::
func(key []byte, nonce []byte) ([]byte, error)
vendor/golang.org/x/crypto/internal/poly1305.Sum
::
func(out *[16]byte, m []byte, key *[32]byte)
vendor/golang.org/x/crypto/internal/poly1305.Verify
::
func(mac *[16]byte, m []byte, key *[32]byte) bool
vendor/golang.org/x/crypto/internal/poly1305.New
::
func(key *[32]byte) *vendor/golang.org/x/crypto/internal/poly1305.MAC
vendor/golang.org/x/crypto/chacha20poly1305.New
::
func(key []byte) (crypto/cipher.AEAD, error)
vendor/golang.org/x/crypto/chacha20poly1305.NewX
::
func(key []byte) (crypto/cipher.AEAD, error)
vendor/golang.org/x/crypto/hkdf.Extract
::
func(hash func() hash.Hash, secret []byte, salt []byte) []byte
vendor/golang.org/x/crypto/hkdf.Expand
::
func(hash func() hash.Hash, pseudorandomKey []byte, info []byte) io.Reader
vendor/golang.org/x/crypto/hkdf.New
::
func(hash func() hash.Hash, secret []byte, salt []byte, info []byte) io.Reader
crypto/tls.CipherSuites
::
func() []*crypto/tls.CipherSuite
crypto/tls.InsecureCipherSuites
::
func() []*crypto/tls.CipherSuite
crypto/tls.CipherSuiteName
::
func(id uint16) string
crypto/tls.VersionName
::
func(version uint16) string
crypto/tls.NewLRUClientSessionCache
::
func(capacity int) crypto/tls.ClientSessionCache
crypto/tls.QUICClient
::
func(config *crypto/tls.QUICConfig) *crypto/tls.QUICConn
crypto/tls.QUICServer
::
func(config *crypto/tls.QUICConfig) *crypto/tls.QUICConn
crypto/tls.ParseSessionState
::
func(data []byte) (*crypto/tls.SessionState, error)
crypto/tls.NewResumptionState
::
func(ticket []byte, state *crypto/tls.SessionState) (*crypto/tls.ClientSessionState, error)
crypto/tls.Server
::
func(conn net.Conn, config *crypto/tls.Config) *crypto/tls.Conn
crypto/tls.Client
::
func(conn net.Conn, config *crypto/tls.Config) *crypto/tls.Conn
crypto/tls.NewListener
::
func(inner net.Listener, config *crypto/tls.Config) net.Listener
crypto/tls.Listen
::
func(network string, laddr string, config *crypto/tls.Config) (net.Listener, error)
crypto/tls.DialWithDialer
::
func(dialer *net.Dialer, network string, addr string, config *crypto/tls.Config) (*crypto/tls.Conn, error)
crypto/tls.Dial
::
func(network string, addr string, config *crypto/tls.Config) (*crypto/tls.Conn, error)
crypto/tls.LoadX509KeyPair
::
func(certFile string, keyFile string) (crypto/tls.Certificate, error)
crypto/tls.X509KeyPair
::
func(certPEMBlock []byte, keyPEMBlock []byte) (crypto/tls.Certificate, error)
database/sql/driver.IsValue
::
func(v any) bool
database/sql/driver.IsScanValue
::
func(v any) bool
database/sql.Register
::
func(name string, driver database/sql/driver.Driver)
database/sql.Drivers
::
func() []string
database/sql.Named
::
func(name string, value any) database/sql.NamedArg
database/sql.OpenDB
::
func(c database/sql/driver.Connector) *database/sql.DB
database/sql.Open
::
func(driverName string, dataSourceName string) (*database/sql.DB, error)
debug/dwarf.New
::
func(abbrev []byte, aranges []byte, frame []byte, info []byte, line []byte, pubnames []byte, ranges []byte, str []byte) (*debug/dwarf.Data, error)
internal/saferio.ReadData
::
func(r io.Reader, n uint64) ([]byte, error)
internal/saferio.ReadDataAt
::
func(r io.ReaderAt, n uint64, off int64) ([]byte, error)
internal/saferio.SliceCapWithSize
::
func(size uint64, c uint64) int
internal/saferio.SliceCap
::
func[E any](c uint64) int
internal/zstd.NewReader
::
func(input io.Reader) *internal/zstd.Reader
debug/elf.R_SYM32
::
func(info uint32) uint32
debug/elf.R_TYPE32
::
func(info uint32) uint32
debug/elf.R_INFO32
::
func(sym uint32, typ uint32) uint32
debug/elf.ST_BIND
::
func(info uint8) debug/elf.SymBind
debug/elf.ST_TYPE
::
func(info uint8) debug/elf.SymType
debug/elf.ST_INFO
::
func(bind debug/elf.SymBind, typ debug/elf.SymType) uint8
debug/elf.ST_VISIBILITY
::
func(other uint8) debug/elf.SymVis
debug/elf.R_SYM64
::
func(info uint64) uint32
debug/elf.R_TYPE64
::
func(info uint64) uint32
debug/elf.R_INFO
::
func(sym uint32, typ uint32) uint64
debug/elf.Open
::
func(name string) (*debug/elf.File, error)
debug/elf.NewFile
::
func(r io.ReaderAt) (*debug/elf.File, error)
debug/macho.NewFatFile
::
func(r io.ReaderAt) (*debug/macho.FatFile, error)
debug/macho.OpenFat
::
func(name string) (*debug/macho.FatFile, error)
debug/macho.Open
::
func(name string) (*debug/macho.File, error)
debug/macho.NewFile
::
func(r io.ReaderAt) (*debug/macho.File, error)
debug/pe.Open
::
func(name string) (*debug/pe.File, error)
debug/pe.NewFile
::
func(r io.ReaderAt) (*debug/pe.File, error)
debug/plan9obj.Open
::
func(name string) (*debug/plan9obj.File, error)
debug/plan9obj.NewFile
::
func(r io.ReaderAt) (*debug/plan9obj.File, error)
internal/xcoff.OpenArchive
::
func(name string) (*internal/xcoff.Archive, error)
internal/xcoff.NewArchive
::
func(r io.ReaderAt) (*internal/xcoff.Archive, error)
internal/xcoff.Open
::
func(name string) (*internal/xcoff.File, error)
internal/xcoff.NewFile
::
func(r io.ReaderAt) (*internal/xcoff.File, error)
runtime/debug.ReadGCStats
::
func(stats *runtime/debug.GCStats)
runtime/debug.SetGCPercent
::
func(percent int) int
runtime/debug.FreeOSMemory
::
func()
runtime/debug.SetMaxStack
::
func(bytes int) int
runtime/debug.SetMaxThreads
::
func(threads int) int
runtime/debug.SetPanicOnFault
::
func(enabled bool) bool
runtime/debug.WriteHeapDump
::
func(fd uintptr)
runtime/debug.SetTraceback
::
func(level string)
runtime/debug.SetMemoryLimit
::
func(limit int64) int64
runtime/debug.ReadBuildInfo
::
func() (info *runtime/debug.BuildInfo, ok bool)
runtime/debug.ParseBuildInfo
::
func(data string) (bi *runtime/debug.BuildInfo, err error)
runtime/debug.PrintStack
::
func()
runtime/debug.Stack
::
func() []byte
debug/buildinfo.ReadFile
::
func(name string) (info *runtime/debug.BuildInfo, err error)
debug/buildinfo.Read
::
func(r io.ReaderAt) (*runtime/debug.BuildInfo, error)
debug/gosym.NewLineTable
::
func(data []byte, text uint64) *debug/gosym.LineTable
debug/gosym.NewTable
::
func(symtab []byte, pcln *debug/gosym.LineTable) (*debug/gosym.Table, error)
encoding/ascii85.Encode
::
func(dst []byte, src []byte) int
encoding/ascii85.MaxEncodedLen
::
func(n int) int
encoding/ascii85.NewEncoder
::
func(w io.Writer) io.WriteCloser
encoding/ascii85.Decode
::
func(dst []byte, src []byte, flush bool) (ndst int, nsrc int, err error)
encoding/ascii85.NewDecoder
::
func(r io.Reader) io.Reader
encoding/base32.NewEncoding
::
func(encoder string) *encoding/base32.Encoding
encoding/base32.NewEncoder
::
func(enc *encoding/base32.Encoding, w io.Writer) io.WriteCloser
encoding/base32.NewDecoder
::
func(enc *encoding/base32.Encoding, r io.Reader) io.Reader
encoding/csv.NewReader
::
func(r io.Reader) *encoding/csv.Reader
encoding/csv.NewWriter
::
func(w io.Writer) *encoding/csv.Writer
encoding/gob.NewDecoder
::
func(r io.Reader) *encoding/gob.Decoder
encoding/gob.NewEncoder
::
func(w io.Writer) *encoding/gob.Encoder
encoding/gob.RegisterName
::
func(name string, value any)
encoding/gob.Register
::
func(value any)
encoding/json.Unmarshal
::
func(data []byte, v any) error
encoding/json.Marshal
::
func(v any) ([]byte, error)
encoding/json.MarshalIndent
::
func(v any, prefix string, indent string) ([]byte, error)
encoding/json.HTMLEscape
::
func(dst *bytes.Buffer, src []byte)
encoding/json.Compact
::
func(dst *bytes.Buffer, src []byte) error
encoding/json.Indent
::
func(dst *bytes.Buffer, src []byte, prefix string, indent string) error
encoding/json.Valid
::
func(data []byte) bool
encoding/json.NewDecoder
::
func(r io.Reader) *encoding/json.Decoder
encoding/json.NewEncoder
::
func(w io.Writer) *encoding/json.Encoder
encoding/xml.Marshal
::
func(v any) ([]byte, error)
encoding/xml.MarshalIndent
::
func(v any, prefix string, indent string) ([]byte, error)
encoding/xml.NewEncoder
::
func(w io.Writer) *encoding/xml.Encoder
encoding/xml.Unmarshal
::
func(data []byte, v any) error
encoding/xml.CopyToken
::
func(t encoding/xml.Token) encoding/xml.Token
encoding/xml.NewDecoder
::
func(r io.Reader) *encoding/xml.Decoder
encoding/xml.NewTokenDecoder
::
func(t encoding/xml.TokenReader) *encoding/xml.Decoder
encoding/xml.EscapeText
::
func(w io.Writer, s []byte) error
encoding/xml.Escape
::
func(w io.Writer, s []byte)
log.New
::
func(out io.Writer, prefix string, flag int) *log.Logger
log.Default
::
func() *log.Logger
log.SetOutput
::
func(w io.Writer)
log.Flags
::
func() int
log.SetFlags
::
func(flag int)
log.Prefix
::
func() string
log.SetPrefix
::
func(prefix string)
log.Writer
::
func() io.Writer
log.Print
::
func(v ...any)
log.Printf
::
func(format string, v ...any)
log.Println
::
func(v ...any)
log.Fatal
::
func(v ...any)
log.Fatalf
::
func(format string, v ...any)
log.Fatalln
::
func(v ...any)
log.Panic
::
func(v ...any)
log.Panicf
::
func(format string, v ...any)
log.Panicln
::
func(v ...any)
log.Output
::
func(calldepth int, s string) error
vendor/golang.org/x/text/transform.NewReader
::
func(r io.Reader, t vendor/golang.org/x/text/transform.Transformer) *vendor/golang.org/x/text/transform.Reader
vendor/golang.org/x/text/transform.NewWriter
::
func(w io.Writer, t vendor/golang.org/x/text/transform.Transformer) *vendor/golang.org/x/text/transform.Writer
vendor/golang.org/x/text/transform.Chain
::
func(t ...vendor/golang.org/x/text/transform.Transformer) vendor/golang.org/x/text/transform.Transformer
vendor/golang.org/x/text/transform.RemoveFunc
::
func(f func(r rune) bool) vendor/golang.org/x/text/transform.Transformer
vendor/golang.org/x/text/transform.String
::
func(t vendor/golang.org/x/text/transform.Transformer, s string) (result string, n int, err error)
vendor/golang.org/x/text/transform.Bytes
::
func(t vendor/golang.org/x/text/transform.Transformer, b []byte) (result []byte, n int, err error)
vendor/golang.org/x/text/transform.Append
::
func(t vendor/golang.org/x/text/transform.Transformer, dst []byte, src []byte) (result []byte, n int, err error)
vendor/golang.org/x/text/unicode/bidi.DefaultDirection
::
func(d vendor/golang.org/x/text/unicode/bidi.Direction) vendor/golang.org/x/text/unicode/bidi.Option
vendor/golang.org/x/text/unicode/bidi.AppendReverse
::
func(out []byte, in []byte) []byte
vendor/golang.org/x/text/unicode/bidi.ReverseString
::
func(s string) string
vendor/golang.org/x/text/unicode/bidi.LookupRune
::
func(r rune) (p vendor/golang.org/x/text/unicode/bidi.Properties, size int)
vendor/golang.org/x/text/unicode/bidi.Lookup
::
func(s []byte) (p vendor/golang.org/x/text/unicode/bidi.Properties, sz int)
vendor/golang.org/x/text/unicode/bidi.LookupString
::
func(s string) (p vendor/golang.org/x/text/unicode/bidi.Properties, sz int)
vendor/golang.org/x/text/secure/bidirule.Direction
::
func(b []byte) vendor/golang.org/x/text/unicode/bidi.Direction
vendor/golang.org/x/text/secure/bidirule.DirectionString
::
func(s string) vendor/golang.org/x/text/unicode/bidi.Direction
vendor/golang.org/x/text/secure/bidirule.Valid
::
func(b []byte) bool
vendor/golang.org/x/text/secure/bidirule.ValidString
::
func(s string) bool
vendor/golang.org/x/text/secure/bidirule.New
::
func() *vendor/golang.org/x/text/secure/bidirule.Transformer
vendor/golang.org/x/net/idna.ToASCII
::
func(s string) (string, error)
vendor/golang.org/x/net/idna.ToUnicode
::
func(s string) (string, error)
vendor/golang.org/x/net/idna.Transitional
::
func(transitional bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.VerifyDNSLength
::
func(verify bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.RemoveLeadingDots
::
func(remove bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.ValidateLabels
::
func(enable bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.CheckHyphens
::
func(enable bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.CheckJoiners
::
func(enable bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.StrictDomainName
::
func(use bool) vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.BidiRule
::
func() vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.ValidateForRegistration
::
func() vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.MapForLookup
::
func() vendor/golang.org/x/net/idna.Option
vendor/golang.org/x/net/idna.New
::
func(o ...vendor/golang.org/x/net/idna.Option) *vendor/golang.org/x/net/idna.Profile
net/textproto.NewReader
::
func(r *bufio.Reader) *net/textproto.Reader
net/textproto.CanonicalMIMEHeaderKey
::
func(s string) string
net/textproto.NewConn
::
func(conn io.ReadWriteCloser) *net/textproto.Conn
net/textproto.Dial
::
func(network string, addr string) (*net/textproto.Conn, error)
net/textproto.TrimString
::
func(s string) string
net/textproto.TrimBytes
::
func(b []byte) []byte
net/textproto.NewWriter
::
func(w *bufio.Writer) *net/textproto.Writer
vendor/golang.org/x/net/http/httpguts.ValidTrailerHeader
::
func(name string) bool
vendor/golang.org/x/net/http/httpguts.IsTokenRune
::
func(r rune) bool
vendor/golang.org/x/net/http/httpguts.HeaderValuesContainsToken
::
func(values []string, token string) bool
vendor/golang.org/x/net/http/httpguts.ValidHeaderFieldName
::
func(v string) bool
vendor/golang.org/x/net/http/httpguts.ValidHostHeader
::
func(h string) bool
vendor/golang.org/x/net/http/httpguts.ValidHeaderFieldValue
::
func(v string) bool
vendor/golang.org/x/net/http/httpguts.PunycodeHostPort
::
func(v string) (string, error)
vendor/golang.org/x/net/http/httpproxy.FromEnvironment
::
func() *vendor/golang.org/x/net/http/httpproxy.Config
vendor/golang.org/x/net/http2/hpack.NewEncoder
::
func(w io.Writer) *vendor/golang.org/x/net/http2/hpack.Encoder
vendor/golang.org/x/net/http2/hpack.NewDecoder
::
func(maxDynamicTableSize uint32, emitFunc func(f vendor/golang.org/x/net/http2/hpack.HeaderField)) *vendor/golang.org/x/net/http2/hpack.Decoder
vendor/golang.org/x/net/http2/hpack.HuffmanDecode
::
func(w io.Writer, v []byte) (int, error)
vendor/golang.org/x/net/http2/hpack.HuffmanDecodeToString
::
func(v []byte) (string, error)
vendor/golang.org/x/net/http2/hpack.AppendHuffmanString
::
func(dst []byte, s string) []byte
vendor/golang.org/x/net/http2/hpack.HuffmanEncodeLength
::
func(s string) uint64
mime.FormatMediaType
::
func(t string, param map[string]string) string
mime.ParseMediaType
::
func(v string) (mediatype string, params map[string]string, err error)
mime.TypeByExtension
::
func(ext string) string
mime.ExtensionsByType
::
func(typ string) ([]string, error)
mime.AddExtensionType
::
func(ext string, typ string) error
mime/quotedprintable.NewReader
::
func(r io.Reader) *mime/quotedprintable.Reader
mime/quotedprintable.NewWriter
::
func(w io.Writer) *mime/quotedprintable.Writer
mime/multipart.NewReader
::
func(r io.Reader, boundary string) *mime/multipart.Reader
mime/multipart.NewWriter
::
func(w io.Writer) *mime/multipart.Writer
net/http/httptrace.ContextClientTrace
::
func(ctx context.Context) *net/http/httptrace.ClientTrace
net/http/httptrace.WithClientTrace
::
func(ctx context.Context, trace *net/http/httptrace.ClientTrace) context.Context
net/http/internal.NewChunkedReader
::
func(r io.Reader) io.Reader
net/http/internal.NewChunkedWriter
::
func(w io.Writer) io.WriteCloser
net/http/internal/ascii.EqualFold
::
func(s string, t string) bool
net/http/internal/ascii.IsPrint
::
func(s string) bool
net/http/internal/ascii.Is
::
func(s string) bool
net/http/internal/ascii.ToLower
::
func(s string) (lower string, ok bool)
net/http.Get
::
func(url string) (resp *net/http.Response, err error)
net/http.Post
::
func(url string, contentType string, body io.Reader) (resp *net/http.Response, err error)
net/http.PostForm
::
func(url string, data net/url.Values) (resp *net/http.Response, err error)
net/http.Head
::
func(url string) (resp *net/http.Response, err error)
net/http.SetCookie
::
func(w net/http.ResponseWriter, cookie *net/http.Cookie)
net/http.NewFileTransport
::
func(fs net/http.FileSystem) net/http.RoundTripper
net/http.NewFileTransportFS
::
func(fsys io/fs.FS) net/http.RoundTripper
net/http.ServeContent
::
func(w net/http.ResponseWriter, req *net/http.Request, name string, modtime time.Time, content io.ReadSeeker)
net/http.ServeFile
::
func(w net/http.ResponseWriter, r *net/http.Request, name string)
net/http.ServeFileFS
::
func(w net/http.ResponseWriter, r *net/http.Request, fsys io/fs.FS, name string)
net/http.FS
::
func(fsys io/fs.FS) net/http.FileSystem
net/http.FileServer
::
func(root net/http.FileSystem) net/http.Handler
net/http.FileServerFS
::
func(root io/fs.FS) net/http.Handler
net/http.ParseTime
::
func(text string) (t time.Time, err error)
net/http.CanonicalHeaderKey
::
func(s string) string
net/http.ParseHTTPVersion
::
func(vers string) (major int, minor int, ok bool)
net/http.NewRequest
::
func(method string, url string, body io.Reader) (*net/http.Request, error)
net/http.NewRequestWithContext
::
func(ctx context.Context, method string, url string, body io.Reader) (*net/http.Request, error)
net/http.ReadRequest
::
func(b *bufio.Reader) (*net/http.Request, error)
net/http.MaxBytesReader
::
func(w net/http.ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser
net/http.ReadResponse
::
func(r *bufio.Reader, req *net/http.Request) (*net/http.Response, error)
net/http.NewResponseController
::
func(rw net/http.ResponseWriter) *net/http.ResponseController
net/http.Error
::
func(w net/http.ResponseWriter, error string, code int)
net/http.NotFound
::
func(w net/http.ResponseWriter, r *net/http.Request)
net/http.NotFoundHandler
::
func() net/http.Handler
net/http.StripPrefix
::
func(prefix string, h net/http.Handler) net/http.Handler
net/http.Redirect
::
func(w net/http.ResponseWriter, r *net/http.Request, url string, code int)
net/http.RedirectHandler
::
func(url string, code int) net/http.Handler
net/http.NewServeMux
::
func() *net/http.ServeMux
net/http.Handle
::
func(pattern string, handler net/http.Handler)
net/http.HandleFunc
::
func(pattern string, handler func(net/http.ResponseWriter, *net/http.Request))
net/http.Serve
::
func(l net.Listener, handler net/http.Handler) error
net/http.ServeTLS
::
func(l net.Listener, handler net/http.Handler, certFile string, keyFile string) error
net/http.AllowQuerySemicolons
::
func(h net/http.Handler) net/http.Handler
net/http.ListenAndServe
::
func(addr string, handler net/http.Handler) error
net/http.ListenAndServeTLS
::
func(addr string, certFile string, keyFile string, handler net/http.Handler) error
net/http.TimeoutHandler
::
func(h net/http.Handler, dt time.Duration, msg string) net/http.Handler
net/http.MaxBytesHandler
::
func(h net/http.Handler, n int64) net/http.Handler
net/http.DetectContentType
::
func(data []byte) string
net/http.StatusText
::
func(code int) string
net/http.ProxyFromEnvironment
::
func(req *net/http.Request) (*net/url.URL, error)
net/http.ProxyURL
::
func(fixedURL *net/url.URL) func(*net/http.Request) (*net/url.URL, error)
expvar.Publish
::
func(name string, v expvar.Var)
expvar.Get
::
func(name string) expvar.Var
expvar.NewInt
::
func(name string) *expvar.Int
expvar.NewFloat
::
func(name string) *expvar.Float
expvar.NewMap
::
func(name string) *expvar.Map
expvar.NewString
::
func(name string) *expvar.String
expvar.Do
::
func(f func(expvar.KeyValue))
expvar.Handler
::
func() net/http.Handler
flag.VisitAll
::
func(fn func(*flag.Flag))
flag.Visit
::
func(fn func(*flag.Flag))
flag.Lookup
::
func(name string) *flag.Flag
flag.Set
::
func(name string, value string) error
flag.UnquoteUsage
::
func(flag *flag.Flag) (name string, usage string)
flag.PrintDefaults
::
func()
flag.NFlag
::
func() int
flag.Arg
::
func(i int) string
flag.NArg
::
func() int
flag.Args
::
func() []string
flag.BoolVar
::
func(p *bool, name string, value bool, usage string)
flag.Bool
::
func(name string, value bool, usage string) *bool
flag.IntVar
::
func(p *int, name string, value int, usage string)
flag.Int
::
func(name string, value int, usage string) *int
flag.Int64Var
::
func(p *int64, name string, value int64, usage string)
flag.Int64
::
func(name string, value int64, usage string) *int64
flag.UintVar
::
func(p *uint, name string, value uint, usage string)
flag.Uint
::
func(name string, value uint, usage string) *uint
flag.Uint64Var
::
func(p *uint64, name string, value uint64, usage string)
flag.Uint64
::
func(name string, value uint64, usage string) *uint64
flag.StringVar
::
func(p *string, name string, value string, usage string)
flag.String
::
func(name string, value string, usage string) *string
flag.Float64Var
::
func(p *float64, name string, value float64, usage string)
flag.Float64
::
func(name string, value float64, usage string) *float64
flag.DurationVar
::
func(p *time.Duration, name string, value time.Duration, usage string)
flag.Duration
::
func(name string, value time.Duration, usage string) *time.Duration
flag.TextVar
::
func(p encoding.TextUnmarshaler, name string, value encoding.TextMarshaler, usage string)
flag.Func
::
func(name string, usage string, fn func(string) error)
flag.BoolFunc
::
func(name string, usage string, fn func(string) error)
flag.Var
::
func(value flag.Value, name string, usage string)
flag.Parse
::
func()
flag.Parsed
::
func() bool
flag.NewFlagSet
::
func(name string, errorHandling flag.ErrorHandling) *flag.FlagSet
go/token.NewFileSet
::
func() *go/token.FileSet
go/token.Lookup
::
func(ident string) go/token.Token
go/token.IsExported
::
func(name string) bool
go/token.IsKeyword
::
func(name string) bool
go/token.IsIdentifier
::
func(name string) bool
go/scanner.PrintError
::
func(w io.Writer, err error)
go/ast.NewIdent
::
func(name string) *go/ast.Ident
go/ast.IsExported
::
func(name string) bool
go/ast.IsGenerated
::
func(file *go/ast.File) bool
go/ast.Unparen
::
func(e go/ast.Expr) go/ast.Expr
go/ast.NewCommentMap
::
func(fset *go/token.FileSet, node go/ast.Node, comments []*go/ast.CommentGroup) go/ast.CommentMap
go/ast.FileExports
::
func(src *go/ast.File) bool
go/ast.PackageExports
::
func(pkg *go/ast.Package) bool
go/ast.FilterDecl
::
func(decl go/ast.Decl, f go/ast.Filter) bool
go/ast.FilterFile
::
func(src *go/ast.File, f go/ast.Filter) bool
go/ast.FilterPackage
::
func(pkg *go/ast.Package, f go/ast.Filter) bool
go/ast.MergePackageFiles
::
func(pkg *go/ast.Package, mode go/ast.MergeMode) *go/ast.File
go/ast.SortImports
::
func(fset *go/token.FileSet, f *go/ast.File)
go/ast.NotNilFilter
::
func(_ string, v reflect.Value) bool
go/ast.Fprint
::
func(w io.Writer, fset *go/token.FileSet, x any, f go/ast.FieldFilter) error
go/ast.Print
::
func(fset *go/token.FileSet, x any) error
go/ast.NewPackage
::
func(fset *go/token.FileSet, files map[string]*go/ast.File, importer go/ast.Importer, universe *go/ast.Scope) (*go/ast.Package, error)
go/ast.NewScope
::
func(outer *go/ast.Scope) *go/ast.Scope
go/ast.NewObj
::
func(kind go/ast.ObjKind, name string) *go/ast.Object
go/ast.Walk
::
func(v go/ast.Visitor, node go/ast.Node)
go/ast.Inspect
::
func(node go/ast.Node, f func(go/ast.Node) bool)
go/build/constraint.Parse
::
func(line string) (go/build/constraint.Expr, error)
go/build/constraint.IsGoBuild
::
func(line string) bool
go/build/constraint.IsPlusBuild
::
func(line string) bool
go/build/constraint.PlusBuildLines
::
func(x go/build/constraint.Expr) ([]string, error)
go/build/constraint.GoVersion
::
func(x go/build/constraint.Expr) string
go/doc/comment.DefaultLookupPackage
::
func(name string) (importPath string, ok bool)
regexp/syntax.Compile
::
func(re *regexp/syntax.Regexp) (*regexp/syntax.Prog, error)
regexp/syntax.Parse
::
func(s string, flags regexp/syntax.Flags) (*regexp/syntax.Regexp, error)
regexp/syntax.EmptyOpContext
::
func(r1 rune, r2 rune) regexp/syntax.EmptyOp
regexp/syntax.IsWordChar
::
func(r rune) bool
regexp.Compile
::
func(expr string) (*regexp.Regexp, error)
regexp.CompilePOSIX
::
func(expr string) (*regexp.Regexp, error)
regexp.MustCompile
::
func(str string) *regexp.Regexp
regexp.MustCompilePOSIX
::
func(str string) *regexp.Regexp
regexp.MatchReader
::
func(pattern string, r io.RuneReader) (matched bool, err error)
regexp.MatchString
::
func(pattern string, s string) (matched bool, err error)
regexp.Match
::
func(pattern string, b []byte) (matched bool, err error)
regexp.QuoteMeta
::
func(s string) string
internal/lazyregexp.New
::
func(str string) *internal/lazyregexp.Regexp
go/doc.ToHTML
::
func(w io.Writer, text string, words map[string]string)
go/doc.ToText
::
func(w io.Writer, text string, prefix string, codePrefix string, width int)
go/doc.New
::
func(pkg *go/ast.Package, importPath string, mode go/doc.Mode) *go/doc.Package
go/doc.NewFromFiles
::
func(fset *go/token.FileSet, files []*go/ast.File, importPath string, opts ...any) (*go/doc.Package, error)
go/doc.Examples
::
func(testFiles ...*go/ast.File) []*go/doc.Example
go/doc.IsPredeclared
::
func(s string) bool
go/doc.Synopsis
::
func(text string) string
go/internal/typeparams.PackIndexExpr
::
func(x go/ast.Expr, lbrack go/token.Pos, exprs []go/ast.Expr, rbrack go/token.Pos) go/ast.Expr
go/internal/typeparams.UnpackIndexExpr
::
func(n go/ast.Node) *go/internal/typeparams.IndexExpr
go/parser.ParseFile
::
func(fset *go/token.FileSet, filename string, src any, mode go/parser.Mode) (f *go/ast.File, err error)
go/parser.ParseDir
::
func(fset *go/token.FileSet, path string, filter func(io/fs.FileInfo) bool, mode go/parser.Mode) (pkgs map[string]*go/ast.Package, first error)
go/parser.ParseExprFrom
::
func(fset *go/token.FileSet, filename string, src any, mode go/parser.Mode) (expr go/ast.Expr, err error)
go/parser.ParseExpr
::
func(x string) (go/ast.Expr, error)
internal/buildcfg.Check
::
func()
internal/buildcfg.Getgoextlinkenabled
::
func() string
internal/buildcfg.GOGOARCH
::
func() (name string, value string)
internal/buildcfg.ParseGOEXPERIMENT
::
func(goos string, goarch string, goexp string) (*internal/buildcfg.ExperimentFlags, error)
os/exec.Command
::
func(name string, arg ...string) *os/exec.Cmd
os/exec.CommandContext
::
func(ctx context.Context, name string, arg ...string) *os/exec.Cmd
os/exec.LookPath
::
func(file string) (string, error)
internal/goroot.IsStandardPackage
::
func(goroot string, compiler string, path string) bool
internal/platform.RaceDetectorSupported
::
func(goos string, goarch string) bool
internal/platform.MSanSupported
::
func(goos string, goarch string) bool
internal/platform.ASanSupported
::
func(goos string, goarch string) bool
internal/platform.FuzzSupported
::
func(goos string, goarch string) bool
internal/platform.FuzzInstrumented
::
func(goos string, goarch string) bool
internal/platform.MustLinkExternal
::
func(goos string, goarch string, withCgo bool) bool
internal/platform.BuildModeSupported
::
func(compiler string, buildmode string, goos string, goarch string) bool
internal/platform.InternalLinkPIESupported
::
func(goos string, goarch string) bool
internal/platform.DefaultPIE
::
func(goos string, goarch string, isRace bool) bool
internal/platform.ExecutableHasDWARF
::
func(goos string, goarch string) bool
internal/platform.CgoSupported
::
func(goos string, goarch string) bool
internal/platform.FirstClass
::
func(goos string, goarch string) bool
internal/platform.Broken
::
func(goos string, goarch string) bool
go/build.Import
::
func(path string, srcDir string, mode go/build.ImportMode) (*go/build.Package, error)
go/build.ImportDir
::
func(dir string, mode go/build.ImportMode) (*go/build.Package, error)
go/build.IsLocalImport
::
func(path string) bool
go/build.ArchChar
::
func(goarch string) (string, error)
go/constant.MakeUnknown
::
func() go/constant.Value
go/constant.MakeBool
::
func(b bool) go/constant.Value
go/constant.MakeString
::
func(s string) go/constant.Value
go/constant.MakeInt64
::
func(x int64) go/constant.Value
go/constant.MakeUint64
::
func(x uint64) go/constant.Value
go/constant.MakeFloat64
::
func(x float64) go/constant.Value
go/constant.MakeFromLiteral
::
func(lit string, tok go/token.Token, zero uint) go/constant.Value
go/constant.BoolVal
::
func(x go/constant.Value) bool
go/constant.StringVal
::
func(x go/constant.Value) string
go/constant.Int64Val
::
func(x go/constant.Value) (int64, bool)
go/constant.Uint64Val
::
func(x go/constant.Value) (uint64, bool)
go/constant.Float32Val
::
func(x go/constant.Value) (float32, bool)
go/constant.Float64Val
::
func(x go/constant.Value) (float64, bool)
go/constant.Val
::
func(x go/constant.Value) any
go/constant.Make
::
func(x any) go/constant.Value
go/constant.BitLen
::
func(x go/constant.Value) int
go/constant.Sign
::
func(x go/constant.Value) int
go/constant.Bytes
::
func(x go/constant.Value) []byte
go/constant.MakeFromBytes
::
func(bytes []byte) go/constant.Value
go/constant.Num
::
func(x go/constant.Value) go/constant.Value
go/constant.Denom
::
func(x go/constant.Value) go/constant.Value
go/constant.MakeImag
::
func(x go/constant.Value) go/constant.Value
go/constant.Real
::
func(x go/constant.Value) go/constant.Value
go/constant.Imag
::
func(x go/constant.Value) go/constant.Value
go/constant.ToInt
::
func(x go/constant.Value) go/constant.Value
go/constant.ToFloat
::
func(x go/constant.Value) go/constant.Value
go/constant.ToComplex
::
func(x go/constant.Value) go/constant.Value
go/constant.UnaryOp
::
func(op go/token.Token, y go/constant.Value, prec uint) go/constant.Value
go/constant.BinaryOp
::
func(x_ go/constant.Value, op go/token.Token, y_ go/constant.Value) go/constant.Value
go/constant.Shift
::
func(x go/constant.Value, op go/token.Token, s uint) go/constant.Value
go/constant.Compare
::
func(x_ go/constant.Value, op go/token.Token, y_ go/constant.Value) bool
text/tabwriter.NewWriter
::
func(output io.Writer, minwidth int, tabwidth int, padding int, padchar byte, flags uint) *text/tabwriter.Writer
go/printer.Fprint
::
func(output io.Writer, fset *go/token.FileSet, node any) error
go/format.Node
::
func(dst io.Writer, fset *go/token.FileSet, node any) error
go/format.Source
::
func(src []byte) ([]byte, error)
internal/gover.Compare
::
func(x string, y string) int
internal/gover.Max
::
func(x string, y string) string
internal/gover.IsLang
::
func(x string) bool
internal/gover.Lang
::
func(x string) string
internal/gover.IsValid
::
func(x string) bool
internal/gover.Parse
::
func(x string) internal/gover.Version
internal/gover.CmpInt
::
func(x string, y string) int
internal/gover.DecInt
::
func(decimal string) string
go/version.Lang
::
func(x string) string
go/version.Compare
::
func(x string, y string) int
go/version.IsValid
::
func(x string) bool
go/types.NewAlias
::
func(obj *go/types.TypeName, rhs go/types.Type) *go/types.Alias
go/types.Unalias
::
func(t go/types.Type) go/types.Type
go/types.AssertableTo
::
func(V *go/types.Interface, T go/types.Type) bool
go/types.AssignableTo
::
func(V go/types.Type, T go/types.Type) bool
go/types.ConvertibleTo
::
func(V go/types.Type, T go/types.Type) bool
go/types.Implements
::
func(V go/types.Type, T *go/types.Interface) bool
go/types.Satisfies
::
func(V go/types.Type, T *go/types.Interface) bool
go/types.Identical
::
func(x go/types.Type, y go/types.Type) bool
go/types.IdenticalIgnoreTags
::
func(x go/types.Type, y go/types.Type) bool
go/types.NewArray
::
func(elem go/types.Type, len int64) *go/types.Array
go/types.NewChan
::
func(dir go/types.ChanDir, elem go/types.Type) *go/types.Chan
go/types.NewChecker
::
func(conf *go/types.Config, fset *go/token.FileSet, pkg *go/types.Package, info *go/types.Info) *go/types.Checker
go/types.NewContext
::
func() *go/types.Context
go/types.Eval
::
func(fset *go/token.FileSet, pkg *go/types.Package, pos go/token.Pos, expr string) (_ go/types.TypeAndValue, err error)
go/types.CheckExpr
::
func(fset *go/token.FileSet, pkg *go/types.Package, pos go/token.Pos, expr go/ast.Expr, info *go/types.Info) (err error)
go/types.ExprString
::
func(x go/ast.Expr) string
go/types.WriteExpr
::
func(buf *bytes.Buffer, x go/ast.Expr)
go/types.Instantiate
::
func(ctxt *go/types.Context, orig go/types.Type, targs []go/types.Type, validate bool) (go/types.Type, error)
go/types.NewInterface
::
func(methods []*go/types.Func, embeddeds []*go/types.Named) *go/types.Interface
go/types.NewInterfaceType
::
func(methods []*go/types.Func, embeddeds []go/types.Type) *go/types.Interface
go/types.LookupFieldOrMethod
::
func(T go/types.Type, addressable bool, pkg *go/types.Package, name string) (obj go/types.Object, index []int, indirect bool)
go/types.MissingMethod
::
func(V go/types.Type, T *go/types.Interface, static bool) (method *go/types.Func, wrongType bool)
go/types.NewMap
::
func(key go/types.Type, elem go/types.Type) *go/types.Map
go/types.NewMethodSet
::
func(T go/types.Type) *go/types.MethodSet
go/types.NewNamed
::
func(obj *go/types.TypeName, underlying go/types.Type, methods []*go/types.Func) *go/types.Named
go/types.Id
::
func(pkg *go/types.Package, name string) string
go/types.NewPkgName
::
func(pos go/token.Pos, pkg *go/types.Package, name string, imported *go/types.Package) *go/types.PkgName
go/types.NewConst
::
func(pos go/token.Pos, pkg *go/types.Package, name string, typ go/types.Type, val go/constant.Value) *go/types.Const
go/types.NewTypeName
::
func(pos go/token.Pos, pkg *go/types.Package, name string, typ go/types.Type) *go/types.TypeName
go/types.NewVar
::
func(pos go/token.Pos, pkg *go/types.Package, name string, typ go/types.Type) *go/types.Var
go/types.NewParam
::
func(pos go/token.Pos, pkg *go/types.Package, name string, typ go/types.Type) *go/types.Var
go/types.NewField
::
func(pos go/token.Pos, pkg *go/types.Package, name string, typ go/types.Type, embedded bool) *go/types.Var
go/types.NewFunc
::
func(pos go/token.Pos, pkg *go/types.Package, name string, sig *go/types.Signature) *go/types.Func
go/types.NewLabel
::
func(pos go/token.Pos, pkg *go/types.Package, name string) *go/types.Label
go/types.ObjectString
::
func(obj go/types.Object, qf go/types.Qualifier) string
go/types.NewPackage
::
func(path string, name string) *go/types.Package
go/types.NewPointer
::
func(elem go/types.Type) *go/types.Pointer
go/types.IsInterface
::
func(t go/types.Type) bool
go/types.Comparable
::
func(T go/types.Type) bool
go/types.Default
::
func(t go/types.Type) go/types.Type
go/types.NewScope
::
func(parent *go/types.Scope, pos go/token.Pos, end go/token.Pos, comment string) *go/types.Scope
go/types.SelectionString
::
func(s *go/types.Selection, qf go/types.Qualifier) string
go/types.NewSignature
::
func(recv *go/types.Var, params *go/types.Tuple, results *go/types.Tuple, variadic bool) *go/types.Signature
go/types.NewSignatureType
::
func(recv *go/types.Var, recvTypeParams []*go/types.TypeParam, typeParams []*go/types.TypeParam, params *go/types.Tuple, results *go/types.Tuple, variadic bool) *go/types.Signature
go/types.SizesFor
::
func(compiler string, arch string) go/types.Sizes
go/types.NewSlice
::
func(elem go/types.Type) *go/types.Slice
go/types.NewStruct
::
func(fields []*go/types.Var, tags []string) *go/types.Struct
go/types.NewTuple
::
func(x ...*go/types.Var) *go/types.Tuple
go/types.NewTypeParam
::
func(obj *go/types.TypeName, constraint go/types.Type) *go/types.TypeParam
go/types.RelativeTo
::
func(pkg *go/types.Package) go/types.Qualifier
go/types.TypeString
::
func(typ go/types.Type, qf go/types.Qualifier) string
go/types.WriteType
::
func(buf *bytes.Buffer, typ go/types.Type, qf go/types.Qualifier)
go/types.WriteSignature
::
func(buf *bytes.Buffer, sig *go/types.Signature, qf go/types.Qualifier)
go/types.NewUnion
::
func(terms []*go/types.Term) *go/types.Union
go/types.NewTerm
::
func(tilde bool, typ go/types.Type) *go/types.Term
go/types.DefPredeclaredTestFuncs
::
func()
text/scanner.TokenString
::
func(tok rune) string
go/internal/gccgoimporter.GetImporter
::
func(searchpaths []string, initmap map[*go/types.Package]go/internal/gccgoimporter.InitData) go/internal/gccgoimporter.Importer
internal/pkgbits.NewPkgDecoder
::
func(pkgPath string, input string) internal/pkgbits.PkgDecoder
internal/pkgbits.NewPkgEncoder
::
func(syncFrames int) internal/pkgbits.PkgEncoder
go/internal/gcimporter.FindExportData
::
func(r *bufio.Reader) (hdr string, size int, err error)
go/internal/gcimporter.FindPkg
::
func(path string, srcDir string) (filename string, id string, err error)
go/internal/gcimporter.Import
::
func(fset *go/token.FileSet, packages map[string]*go/types.Package, path string, srcDir string, lookup func(path string) (io.ReadCloser, error)) (pkg *go/types.Package, err error)
go/internal/srcimporter.New
::
func(ctxt *go/build.Context, fset *go/token.FileSet, packages map[string]*go/types.Package) *go/internal/srcimporter.Importer
go/importer.ForCompiler
::
func(fset *go/token.FileSet, compiler string, lookup go/importer.Lookup) go/types.Importer
go/importer.For
::
func(compiler string, lookup go/importer.Lookup) go/types.Importer
go/importer.Default
::
func() go/types.Importer
hash/crc64.MakeTable
::
func(poly uint64) *hash/crc64.Table
hash/crc64.New
::
func(tab *hash/crc64.Table) hash.Hash64
hash/crc64.Update
::
func(crc uint64, tab *hash/crc64.Table, p []byte) uint64
hash/crc64.Checksum
::
func(data []byte, tab *hash/crc64.Table) uint64
hash/fnv.New32
::
func() hash.Hash32
hash/fnv.New32a
::
func() hash.Hash32
hash/fnv.New64
::
func() hash.Hash64
hash/fnv.New64a
::
func() hash.Hash64
hash/fnv.New128
::
func() hash.Hash
hash/fnv.New128a
::
func() hash.Hash
hash/maphash.Bytes
::
func(seed hash/maphash.Seed, b []byte) uint64
hash/maphash.String
::
func(seed hash/maphash.Seed, s string) uint64
hash/maphash.MakeSeed
::
func() hash/maphash.Seed
html.EscapeString
::
func(s string) string
html.UnescapeString
::
func(s string) string
text/template/parse.NewIdentifier
::
func(ident string) *text/template/parse.IdentifierNode
text/template/parse.Parse
::
func(name string, text string, leftDelim string, rightDelim string, funcs ...map[string]any) (map[string]*text/template/parse.Tree, error)
text/template/parse.New
::
func(name string, funcs ...map[string]any) *text/template/parse.Tree
text/template/parse.IsEmptyTree
::
func(n text/template/parse.Node) bool
text/template.IsTrue
::
func(val any) (truth bool, ok bool)
text/template.HTMLEscape
::
func(w io.Writer, b []byte)
text/template.HTMLEscapeString
::
func(s string) string
text/template.HTMLEscaper
::
func(args ...any) string
text/template.JSEscape
::
func(w io.Writer, b []byte)
text/template.JSEscapeString
::
func(s string) string
text/template.JSEscaper
::
func(args ...any) string
text/template.URLQueryEscaper
::
func(args ...any) string
text/template.Must
::
func(t *text/template.Template, err error) *text/template.Template
text/template.ParseFiles
::
func(filenames ...string) (*text/template.Template, error)
text/template.ParseGlob
::
func(pattern string) (*text/template.Template, error)
text/template.ParseFS
::
func(fsys io/fs.FS, patterns ...string) (*text/template.Template, error)
text/template.New
::
func(name string) *text/template.Template
html/template.HTMLEscape
::
func(w io.Writer, b []byte)
html/template.HTMLEscapeString
::
func(s string) string
html/template.HTMLEscaper
::
func(args ...any) string
html/template.JSEscape
::
func(w io.Writer, b []byte)
html/template.JSEscapeString
::
func(s string) string
html/template.JSEscaper
::
func(args ...any) string
html/template.URLQueryEscaper
::
func(args ...any) string
html/template.New
::
func(name string) *html/template.Template
html/template.Must
::
func(t *html/template.Template, err error) *html/template.Template
html/template.ParseFiles
::
func(filenames ...string) (*html/template.Template, error)
html/template.ParseGlob
::
func(pattern string) (*html/template.Template, error)
html/template.IsTrue
::
func(val any) (truth bool, ok bool)
html/template.ParseFS
::
func(fs io/fs.FS, patterns ...string) (*html/template.Template, error)
image/color.ModelFunc
::
func(f func(image/color.Color) image/color.Color) image/color.Model
image/color.RGBToYCbCr
::
func(r uint8, g uint8, b uint8) (uint8, uint8, uint8)
image/color.YCbCrToRGB
::
func(y uint8, cb uint8, cr uint8) (uint8, uint8, uint8)
image/color.RGBToCMYK
::
func(r uint8, g uint8, b uint8) (uint8, uint8, uint8, uint8)
image/color.CMYKToRGB
::
func(c uint8, m uint8, y uint8, k uint8) (uint8, uint8, uint8)
image.RegisterFormat
::
func(name string, magic string, decode func(io.Reader) (image.Image, error), decodeConfig func(io.Reader) (image.Config, error))
image.Decode
::
func(r io.Reader) (image.Image, string, error)
image.DecodeConfig
::
func(r io.Reader) (image.Config, string, error)
image.Pt
::
func(X int, Y int) image.Point
image.Rect
::
func(x0 int, y0 int, x1 int, y1 int) image.Rectangle
image.NewRGBA
::
func(r image.Rectangle) *image.RGBA
image.NewRGBA64
::
func(r image.Rectangle) *image.RGBA64
image.NewNRGBA
::
func(r image.Rectangle) *image.NRGBA
image.NewNRGBA64
::
func(r image.Rectangle) *image.NRGBA64
image.NewAlpha
::
func(r image.Rectangle) *image.Alpha
image.NewAlpha16
::
func(r image.Rectangle) *image.Alpha16
image.NewGray
::
func(r image.Rectangle) *image.Gray
image.NewGray16
::
func(r image.Rectangle) *image.Gray16
image.NewCMYK
::
func(r image.Rectangle) *image.CMYK
image.NewPaletted
::
func(r image.Rectangle, p image/color.Palette) *image.Paletted
image.NewUniform
::
func(c image/color.Color) *image.Uniform
image.NewYCbCr
::
func(r image.Rectangle, subsampleRatio image.YCbCrSubsampleRatio) *image.YCbCr
image.NewNYCbCrA
::
func(r image.Rectangle, subsampleRatio image.YCbCrSubsampleRatio) *image.NYCbCrA
image/internal/imageutil.DrawYCbCr
::
func(dst *image.RGBA, r image.Rectangle, src *image.YCbCr, sp image.Point) (ok bool)
image/draw.Draw
::
func(dst image/draw.Image, r image.Rectangle, src image.Image, sp image.Point, op image/draw.Op)
image/draw.DrawMask
::
func(dst image/draw.Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op image/draw.Op)
image/gif.Decode
::
func(r io.Reader) (image.Image, error)
image/gif.DecodeAll
::
func(r io.Reader) (*image/gif.GIF, error)
image/gif.DecodeConfig
::
func(r io.Reader) (image.Config, error)
image/gif.EncodeAll
::
func(w io.Writer, g *image/gif.GIF) error
image/gif.Encode
::
func(w io.Writer, m image.Image, o *image/gif.Options) error
image/jpeg.Decode
::
func(r io.Reader) (image.Image, error)
image/jpeg.DecodeConfig
::
func(r io.Reader) (image.Config, error)
image/jpeg.Encode
::
func(w io.Writer, m image.Image, o *image/jpeg.Options) error
image/png.Decode
::
func(r io.Reader) (image.Image, error)
image/png.DecodeConfig
::
func(r io.Reader) (image.Config, error)
image/png.Encode
::
func(w io.Writer, m image.Image) error
index/suffixarray.New
::
func(data []byte) *index/suffixarray.Index
internal/coverage.ParseCounterMode
::
func(mode string) internal/coverage.CounterMode
internal/coverage.Round4
::
func(x int) int
internal/coverage.HardCodedPkgID
::
func(pkgpath string) int
internal/coverage/cmerge.SaturatingAdd
::
func(dst uint32, src uint32) (uint32, bool)
internal/coverage/cformat.NewFormatter
::
func(cm internal/coverage.CounterMode) *internal/coverage/cformat.Formatter
internal/coverage/slicereader.NewReader
::
func(b []byte, readonly bool) *internal/coverage/slicereader.Reader
internal/coverage/uleb128.AppendUleb128
::
func(b []byte, v uint) []byte
internal/coverage/stringtab.NewReader
::
func(r *internal/coverage/slicereader.Reader) *internal/coverage/stringtab.Reader
internal/coverage/decodecounter.NewCounterDataReader
::
func(fn string, rs io.ReadSeeker) (*internal/coverage/decodecounter.CounterDataReader, error)
internal/coverage/decodemeta.NewCoverageMetaDataDecoder
::
func(b []byte, readonly bool) (*internal/coverage/decodemeta.CoverageMetaDataDecoder, error)
internal/coverage/decodemeta.NewCoverageMetaFileReader
::
func(f *os.File, fileView []byte) (*internal/coverage/decodemeta.CoverageMetaFileReader, error)
internal/coverage/encodecounter.NewCoverageDataWriter
::
func(w io.Writer, flav internal/coverage.CounterFlavor) *internal/coverage/encodecounter.CoverageDataWriter
internal/coverage/encodemeta.NewCoverageMetaDataBuilder
::
func(pkgpath string, pkgname string, modulepath string) (*internal/coverage/encodemeta.CoverageMetaDataBuilder, error)
internal/coverage/encodemeta.HashFuncDesc
::
func(f *internal/coverage.FuncDesc) [16]byte
internal/coverage/encodemeta.NewCoverageMetaFileWriter
::
func(mfname string, w io.Writer) *internal/coverage/encodemeta.CoverageMetaFileWriter
internal/coverage/pods.CollectPods
::
func(dirs []string, warn bool) ([]internal/coverage/pods.Pod, error)
internal/coverage/pods.CollectPodsFromFiles
::
func(files []string, warn bool) []internal/coverage/pods.Pod
internal/dag.Parse
::
func(dag string) (*internal/dag.Graph, error)
internal/diff.Diff
::
func(oldName string, old []byte, newName string, new []byte) []byte
internal/fuzz.ResetCoverage
::
func()
internal/fuzz.SnapshotCoverage
::
func()
internal/fuzz.CoordinateFuzzing
::
func(ctx context.Context, opts internal/fuzz.CoordinateFuzzingOpts) (err error)
internal/fuzz.ReadCorpus
::
func(dir string, types []reflect.Type) ([]struct{Parent string; Path string; Data []byte; Values []any; Generation int; IsSeed bool}, error)
internal/fuzz.CheckCorpus
::
func(vals []any, types []reflect.Type) error
internal/fuzz.RunFuzzWorker
::
func(ctx context.Context, fn func(struct{Parent string; Path string; Data []byte; Values []any; Generation int; IsSeed bool}) error) error
internal/lazytemplate.New
::
func(name string, text string) *internal/lazytemplate.Template
internal/obscuretestdata.Rot13
::
func(data []byte) []byte
internal/obscuretestdata.DecodeToTempFile
::
func(name string) (path string, err error)
internal/obscuretestdata.ReadFile
::
func(name string) ([]byte, error)
internal/profile.ParseTracebacks
::
func(b []byte) (*internal/profile.Profile, error)
internal/profile.Merge
::
func(srcs []*internal/profile.Profile) (*internal/profile.Profile, error)
internal/profile.Parse
::
func(r io.Reader) (*internal/profile.Profile, error)
internal/sysinfo.CPUName
::
func() string
runtime/trace.NewTask
::
func(pctx context.Context, taskType string) (ctx context.Context, task *runtime/trace.Task)
runtime/trace.Log
::
func(ctx context.Context, category string, message string)
runtime/trace.Logf
::
func(ctx context.Context, category string, format string, args ...any)
runtime/trace.WithRegion
::
func(ctx context.Context, regionType string, fn func())
runtime/trace.StartRegion
::
func(ctx context.Context, regionType string) *runtime/trace.Region
runtime/trace.IsEnabled
::
func() bool
runtime/trace.Start
::
func(w io.Writer) error
runtime/trace.Stop
::
func()
testing.AllocsPerRun
::
func(runs int, f func()) (avg float64)
testing.RunBenchmarks
::
func(matchString func(pat string, str string) (bool, error), benchmarks []testing.InternalBenchmark)
testing.Benchmark
::
func(f func(b *testing.B)) testing.BenchmarkResult
testing.Coverage
::
func() float64
testing.RegisterCover
::
func(c testing.Cover)
testing.RunExamples
::
func(matchString func(pat string, str string) (bool, error), examples []testing.InternalExample) (ok bool)
testing.Init
::
func()
testing.Short
::
func() bool
testing.Testing
::
func() bool
testing.CoverMode
::
func() string
testing.Verbose
::
func() bool
testing.Main
::
func(matchString func(pat string, str string) (bool, error), tests []testing.InternalTest, benchmarks []testing.InternalBenchmark, examples []testing.InternalExample)
testing.MainStart
::
func(deps testing.testDeps, tests []testing.InternalTest, benchmarks []testing.InternalBenchmark, fuzzTargets []testing.InternalFuzzTarget, examples []testing.InternalExample) *testing.M
testing.RunTests
::
func(matchString func(pat string, str string) (bool, error), tests []testing.InternalTest) (ok bool)
internal/testenv.MustHaveExec
::
func(t testing.TB)
internal/testenv.MustHaveExecPath
::
func(t testing.TB, path string)
internal/testenv.CleanCmdEnv
::
func(cmd *os/exec.Cmd) *os/exec.Cmd
internal/testenv.CommandContext
::
func(t testing.TB, ctx context.Context, name string, args ...string) *os/exec.Cmd
internal/testenv.Command
::
func(t testing.TB, name string, args ...string) *os/exec.Cmd
internal/testenv.OptimizationOff
::
func() bool
internal/testenv.Builder
::
func() string
internal/testenv.HasGoBuild
::
func() bool
internal/testenv.MustHaveGoBuild
::
func(t testing.TB)
internal/testenv.HasGoRun
::
func() bool
internal/testenv.MustHaveGoRun
::
func(t testing.TB)
internal/testenv.HasParallelism
::
func() bool
internal/testenv.MustHaveParallelism
::
func(t testing.TB)
internal/testenv.GoToolPath
::
func(t testing.TB) string
internal/testenv.GOROOT
::
func(t testing.TB) string
internal/testenv.GoTool
::
func() (string, error)
internal/testenv.HasSrc
::
func() bool
internal/testenv.HasExternalNetwork
::
func() bool
internal/testenv.MustHaveExternalNetwork
::
func(t testing.TB)
internal/testenv.HasCGO
::
func() bool
internal/testenv.MustHaveCGO
::
func(t testing.TB)
internal/testenv.CanInternalLink
::
func(withCgo bool) bool
internal/testenv.MustInternalLink
::
func(t testing.TB, withCgo bool)
internal/testenv.MustHaveBuildMode
::
func(t testing.TB, buildmode string)
internal/testenv.HasSymlink
::
func() bool
internal/testenv.MustHaveSymlink
::
func(t testing.TB)
internal/testenv.HasLink
::
func() bool
internal/testenv.MustHaveLink
::
func(t testing.TB)
internal/testenv.SkipFlaky
::
func(t testing.TB, issue int)
internal/testenv.SkipFlakyNet
::
func(t testing.TB)
internal/testenv.CPUIsSlow
::
func() bool
internal/testenv.SkipIfShortAndSlow
::
func(t testing.TB)
internal/testenv.SkipIfOptimizationOff
::
func(t testing.TB)
internal/testenv.WriteImportcfg
::
func(t testing.TB, dstPath string, packageFiles map[string]string, pkgs ...string)
internal/testenv.SyscallIsNotSupported
::
func(err error) bool
internal/testpty.Open
::
func() (pty *os.File, processTTY string, err error)
internal/trace/v2/event.Names
::
func(specs []internal/trace/v2/event.Spec) map[string]internal/trace/v2/event.Type
internal/trace/v2/event/go122.EventString
::
func(typ internal/trace/v2/event.Type) string
internal/trace/v2/event/go122.Specs
::
func() []internal/trace/v2/event.Spec
internal/trace/v2/version.ReadHeader
::
func(r io.Reader) (internal/trace/v2/version.Version, error)
internal/trace/v2/version.WriteHeader
::
func(w io.Writer, v internal/trace/v2/version.Version) (int, error)
internal/trace/v2.NewReader
::
func(r io.Reader) (*internal/trace/v2.Reader, error)
internal/trace/v2.MakeResourceID
::
func[T interface{internal/trace/v2.GoID | internal/trace/v2.ProcID | internal/trace/v2.ThreadID}](id T) internal/trace/v2.ResourceID
internal/trace.MutatorUtilization
::
func(events []*internal/trace.Event, flags internal/trace.UtilFlags) [][]internal/trace.MutatorUtil
internal/trace.MutatorUtilizationV2
::
func(events []internal/trace/v2.Event, flags internal/trace.UtilFlags) [][]internal/trace.MutatorUtil
internal/trace.NewMMUCurve
::
func(utils [][]internal/trace.MutatorUtil) *internal/trace.MMUCurve
internal/trace.GoroutineStats
::
func(events []*internal/trace.Event) map[uint64]*internal/trace.GDesc
internal/trace.RelatedGoroutines
::
func(events []*internal/trace.Event, goid uint64) map[uint64]bool
internal/trace.IsSystemGoroutine
::
func(entryFn string) bool
internal/trace.Parse
::
func(r io.Reader, bin string) (internal/trace.ParseResult, error)
internal/trace.ReadVersion
::
func(r io.Reader) (ver int, off int, err error)
internal/trace.Print
::
func(events []*internal/trace.Event)
internal/trace.PrintEvent
::
func(ev *internal/trace.Event)
internal/trace.NewSummarizer
::
func() *internal/trace.Summarizer
internal/trace.RelatedGoroutinesV2
::
func(events []internal/trace/v2.Event, goid internal/trace/v2.GoID) map[internal/trace/v2.GoID]struct{}
internal/trace.NewWriter
::
func() *internal/trace.Writer
internal/trace/traceviewer.ViewerDataTraceConsumer
::
func(w io.Writer, startIdx int64, endIdx int64) internal/trace/traceviewer.TraceConsumer
internal/trace/traceviewer.SplittingTraceConsumer
::
func(max int) (*internal/trace/traceviewer.splitter, internal/trace/traceviewer.TraceConsumer)
internal/trace/traceviewer.WalkStackFrames
::
func(allFrames map[string]internal/trace/traceviewer/format.Frame, id int, fn func(id int))
internal/trace/traceviewer.NewEmitter
::
func(c internal/trace/traceviewer.TraceConsumer, rangeStart time.Duration, rangeEnd time.Duration) *internal/trace/traceviewer.Emitter
internal/trace/traceviewer.MainHandler
::
func(views []internal/trace/traceviewer.View) net/http.Handler
internal/trace/traceviewer.TraceHandler
::
func() net/http.Handler
internal/trace/traceviewer.StaticHandler
::
func() net/http.Handler
internal/trace/traceviewer.MMUHandlerFunc
::
func(ranges []internal/trace/traceviewer.Range, f internal/trace/traceviewer.MutatorUtilFunc) net/http.HandlerFunc
internal/trace/traceviewer.SVGProfileHandlerFunc
::
func(f internal/trace/traceviewer.ProfileFunc) net/http.HandlerFunc
internal/trace/traceviewer.BuildProfile
::
func(prof []internal/trace/traceviewer.ProfileRecord) *internal/profile.Profile
internal/trace/v2/raw.NewReader
::
func(r io.Reader) (*internal/trace/v2/raw.Reader, error)
internal/trace/v2/raw.NewTextReader
::
func(r io.Reader) (*internal/trace/v2/raw.TextReader, error)
internal/trace/v2/raw.NewTextWriter
::
func(w io.Writer, v internal/trace/v2/version.Version) (*internal/trace/v2/raw.TextWriter, error)
internal/trace/v2/raw.NewWriter
::
func(w io.Writer, v internal/trace/v2/version.Version) (*internal/trace/v2/raw.Writer, error)
internal/txtar.Format
::
func(a *internal/txtar.Archive) []byte
internal/txtar.ParseFile
::
func(file string) (*internal/txtar.Archive, error)
internal/txtar.Parse
::
func(data []byte) *internal/txtar.Archive
internal/trace/v2/internal/testgen/go122.Main
::
func(f func(*internal/trace/v2/internal/testgen/go122.Trace))
internal/trace/v2/internal/testgen/go122.NewTrace
::
func() *internal/trace/v2/internal/testgen/go122.Trace
internal/trace/v2/testtrace.ExpectSuccess
::
func() *internal/trace/v2/testtrace.Expectation
internal/trace/v2/testtrace.ParseExpectation
::
func(data []byte) (*internal/trace/v2/testtrace.Expectation, error)
internal/trace/v2/testtrace.ParseFile
::
func(testPath string) (io.Reader, *internal/trace/v2/testtrace.Expectation, error)
internal/trace/v2/testtrace.NewValidator
::
func() *internal/trace/v2/testtrace.Validator
io/ioutil.ReadAll
::
func(r io.Reader) ([]byte, error)
io/ioutil.ReadFile
::
func(filename string) ([]byte, error)
io/ioutil.WriteFile
::
func(filename string, data []byte, perm io/fs.FileMode) error
io/ioutil.ReadDir
::
func(dirname string) ([]io/fs.FileInfo, error)
io/ioutil.NopCloser
::
func(r io.Reader) io.ReadCloser
io/ioutil.TempFile
::
func(dir string, pattern string) (f *os.File, err error)
io/ioutil.TempDir
::
func(dir string, pattern string) (name string, err error)
log/slog/internal/buffer.New
::
func() *log/slog/internal/buffer.Buffer
log/slog.String
::
func(key string, value string) log/slog.Attr
log/slog.Int64
::
func(key string, value int64) log/slog.Attr
log/slog.Int
::
func(key string, value int) log/slog.Attr
log/slog.Uint64
::
func(key string, v uint64) log/slog.Attr
log/slog.Float64
::
func(key string, v float64) log/slog.Attr
log/slog.Bool
::
func(key string, v bool) log/slog.Attr
log/slog.Time
::
func(key string, v time.Time) log/slog.Attr
log/slog.Duration
::
func(key string, v time.Duration) log/slog.Attr
log/slog.Group
::
func(key string, args ...any) log/slog.Attr
log/slog.Any
::
func(key string, value any) log/slog.Attr
log/slog.NewJSONHandler
::
func(w io.Writer, opts *log/slog.HandlerOptions) *log/slog.JSONHandler
log/slog.SetLogLoggerLevel
::
func(level log/slog.Level) (oldLevel log/slog.Level)
log/slog.Default
::
func() *log/slog.Logger
log/slog.SetDefault
::
func(l *log/slog.Logger)
log/slog.New
::
func(h log/slog.Handler) *log/slog.Logger
log/slog.With
::
func(args ...any) *log/slog.Logger
log/slog.NewLogLogger
::
func(h log/slog.Handler, level log/slog.Level) *log.Logger
log/slog.Debug
::
func(msg string, args ...any)
log/slog.DebugContext
::
func(ctx context.Context, msg string, args ...any)
log/slog.Info
::
func(msg string, args ...any)
log/slog.InfoContext
::
func(ctx context.Context, msg string, args ...any)
log/slog.Warn
::
func(msg string, args ...any)
log/slog.WarnContext
::
func(ctx context.Context, msg string, args ...any)
log/slog.Error
::
func(msg string, args ...any)
log/slog.ErrorContext
::
func(ctx context.Context, msg string, args ...any)
log/slog.Log
::
func(ctx context.Context, level log/slog.Level, msg string, args ...any)
log/slog.LogAttrs
::
func(ctx context.Context, level log/slog.Level, msg string, attrs ...log/slog.Attr)
log/slog.NewRecord
::
func(t time.Time, level log/slog.Level, msg string, pc uintptr) log/slog.Record
log/slog.NewTextHandler
::
func(w io.Writer, opts *log/slog.HandlerOptions) *log/slog.TextHandler
log/slog.StringValue
::
func(value string) log/slog.Value
log/slog.IntValue
::
func(v int) log/slog.Value
log/slog.Int64Value
::
func(v int64) log/slog.Value
log/slog.Uint64Value
::
func(v uint64) log/slog.Value
log/slog.Float64Value
::
func(v float64) log/slog.Value
log/slog.BoolValue
::
func(v bool) log/slog.Value
log/slog.TimeValue
::
func(v time.Time) log/slog.Value
log/slog.DurationValue
::
func(v time.Duration) log/slog.Value
log/slog.GroupValue
::
func(as ...log/slog.Attr) log/slog.Value
log/slog.AnyValue
::
func(v any) log/slog.Value
log/slog/internal/slogtest.RemoveTime
::
func(groups []string, a log/slog.Attr) log/slog.Attr
log/syslog.New
::
func(priority log/syslog.Priority, tag string) (*log/syslog.Writer, error)
log/syslog.Dial
::
func(network string, raddr string, priority log/syslog.Priority, tag string) (*log/syslog.Writer, error)
log/syslog.NewLogger
::
func(p log/syslog.Priority, logFlag int) (*log.Logger, error)
maps.Equal
::
func[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool
maps.EqualFunc
::
func[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool
maps.Clone
::
func[M ~map[K]V, K comparable, V any](m M) M
maps.Copy
::
func[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)
maps.DeleteFunc
::
func[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)
math/cmplx.Abs
::
func(x complex128) float64
math/cmplx.Asin
::
func(x complex128) complex128
math/cmplx.Asinh
::
func(x complex128) complex128
math/cmplx.Acos
::
func(x complex128) complex128
math/cmplx.Acosh
::
func(x complex128) complex128
math/cmplx.Atan
::
func(x complex128) complex128
math/cmplx.Atanh
::
func(x complex128) complex128
math/cmplx.Conj
::
func(x complex128) complex128
math/cmplx.Exp
::
func(x complex128) complex128
math/cmplx.IsInf
::
func(x complex128) bool
math/cmplx.Inf
::
func() complex128
math/cmplx.IsNaN
::
func(x complex128) bool
math/cmplx.NaN
::
func() complex128
math/cmplx.Log
::
func(x complex128) complex128
math/cmplx.Log10
::
func(x complex128) complex128
math/cmplx.Phase
::
func(x complex128) float64
math/cmplx.Polar
::
func(x complex128) (r float64, θ float64)
math/cmplx.Pow
::
func(x complex128, y complex128) complex128
math/cmplx.Rect
::
func(r float64, θ float64) complex128
math/cmplx.Sin
::
func(x complex128) complex128
math/cmplx.Sinh
::
func(x complex128) complex128
math/cmplx.Cos
::
func(x complex128) complex128
math/cmplx.Cosh
::
func(x complex128) complex128
math/cmplx.Sqrt
::
func(x complex128) complex128
math/cmplx.Tan
::
func(x complex128) complex128
math/cmplx.Tanh
::
func(x complex128) complex128
math/cmplx.Cot
::
func(x complex128) complex128
math/rand/v2.NewChaCha8
::
func(seed [32]byte) *math/rand/v2.ChaCha8
math/rand/v2.NewPCG
::
func(seed1 uint64, seed2 uint64) *math/rand/v2.PCG
math/rand/v2.New
::
func(src math/rand/v2.Source) *math/rand/v2.Rand
math/rand/v2.Int64
::
func() int64
math/rand/v2.Uint32
::
func() uint32
math/rand/v2.Uint64N
::
func(n uint64) uint64
math/rand/v2.Uint32N
::
func(n uint32) uint32
math/rand/v2.Uint64
::
func() uint64
math/rand/v2.Int32
::
func() int32
math/rand/v2.Int
::
func() int
math/rand/v2.Int64N
::
func(n int64) int64
math/rand/v2.Int32N
::
func(n int32) int32
math/rand/v2.IntN
::
func(n int) int
math/rand/v2.UintN
::
func(n uint) uint
math/rand/v2.N
::
func[Int math/rand/v2.intType](n Int) Int
math/rand/v2.Float64
::
func() float64
math/rand/v2.Float32
::
func() float32
math/rand/v2.Perm
::
func(n int) []int
math/rand/v2.Shuffle
::
func(n int, swap func(i int, j int))
math/rand/v2.NormFloat64
::
func() float64
math/rand/v2.ExpFloat64
::
func() float64
math/rand/v2.NewZipf
::
func(r *math/rand/v2.Rand, s float64, v float64, imax uint64) *math/rand/v2.Zipf
net/http/cgi.Request
::
func() (*net/http.Request, error)
net/http/cgi.RequestFromMap
::
func(params map[string]string) (*net/http.Request, error)
net/http/cgi.Serve
::
func(handler net/http.Handler) error
net/http/cookiejar.New
::
func(o *net/http/cookiejar.Options) (*net/http/cookiejar.Jar, error)
net/http/fcgi.Serve
::
func(l net.Listener, handler net/http.Handler) error
net/http/fcgi.ProcessEnv
::
func(r *net/http.Request) map[string]string
net/http/httptest.NewRequest
::
func(method string, target string, body io.Reader) *net/http.Request
net/http/httptest.NewRecorder
::
func() *net/http/httptest.ResponseRecorder
net/http/httptest.NewServer
::
func(handler net/http.Handler) *net/http/httptest.Server
net/http/httptest.NewUnstartedServer
::
func(handler net/http.Handler) *net/http/httptest.Server
net/http/httptest.NewTLSServer
::
func(handler net/http.Handler) *net/http/httptest.Server
net/http/httputil.DumpRequestOut
::
func(req *net/http.Request, body bool) ([]byte, error)
net/http/httputil.DumpRequest
::
func(req *net/http.Request, body bool) ([]byte, error)
net/http/httputil.DumpResponse
::
func(resp *net/http.Response, body bool) ([]byte, error)
net/http/httputil.NewChunkedReader
::
func(r io.Reader) io.Reader
net/http/httputil.NewChunkedWriter
::
func(w io.Writer) io.WriteCloser
net/http/httputil.NewServerConn
::
func(c net.Conn, r *bufio.Reader) *net/http/httputil.ServerConn
net/http/httputil.NewClientConn
::
func(c net.Conn, r *bufio.Reader) *net/http/httputil.ClientConn
net/http/httputil.NewProxyClientConn
::
func(c net.Conn, r *bufio.Reader) *net/http/httputil.ClientConn
net/http/httputil.NewSingleHostReverseProxy
::
func(target *net/url.URL) *net/http/httputil.ReverseProxy
runtime/pprof.WithLabels
::
func(ctx context.Context, labels runtime/pprof.LabelSet) context.Context
runtime/pprof.Labels
::
func(args ...string) runtime/pprof.LabelSet
runtime/pprof.Label
::
func(ctx context.Context, key string) (string, bool)
runtime/pprof.ForLabels
::
func(ctx context.Context, f func(key string, value string) bool)
runtime/pprof.NewProfile
::
func(name string) *runtime/pprof.Profile
runtime/pprof.Lookup
::
func(name string) *runtime/pprof.Profile
runtime/pprof.Profiles
::
func() []*runtime/pprof.Profile
runtime/pprof.WriteHeapProfile
::
func(w io.Writer) error
runtime/pprof.StartCPUProfile
::
func(w io.Writer) error
runtime/pprof.StopCPUProfile
::
func()
runtime/pprof.SetGoroutineLabels
::
func(ctx context.Context)
runtime/pprof.Do
::
func(ctx context.Context, labels runtime/pprof.LabelSet, f func(context.Context))
net/http/pprof.Cmdline
::
func(w net/http.ResponseWriter, r *net/http.Request)
net/http/pprof.Profile
::
func(w net/http.ResponseWriter, r *net/http.Request)
net/http/pprof.Trace
::
func(w net/http.ResponseWriter, r *net/http.Request)
net/http/pprof.Symbol
::
func(w net/http.ResponseWriter, r *net/http.Request)
net/http/pprof.Handler
::
func(name string) net/http.Handler
net/http/pprof.Index
::
func(w net/http.ResponseWriter, r *net/http.Request)
net/mail.ReadMessage
::
func(r io.Reader) (msg *net/mail.Message, err error)
net/mail.ParseDate
::
func(date string) (time.Time, error)
net/mail.ParseAddress
::
func(address string) (*net/mail.Address, error)
net/mail.ParseAddressList
::
func(list string) ([]*net/mail.Address, error)
net/rpc.NewClient
::
func(conn io.ReadWriteCloser) *net/rpc.Client
net/rpc.NewClientWithCodec
::
func(codec net/rpc.ClientCodec) *net/rpc.Client
net/rpc.DialHTTP
::
func(network string, address string) (*net/rpc.Client, error)
net/rpc.DialHTTPPath
::
func(network string, address string, path string) (*net/rpc.Client, error)
net/rpc.Dial
::
func(network string, address string) (*net/rpc.Client, error)
net/rpc.NewServer
::
func() *net/rpc.Server
net/rpc.Register
::
func(rcvr any) error
net/rpc.RegisterName
::
func(name string, rcvr any) error
net/rpc.ServeConn
::
func(conn io.ReadWriteCloser)
net/rpc.ServeCodec
::
func(codec net/rpc.ServerCodec)
net/rpc.ServeRequest
::
func(codec net/rpc.ServerCodec) error
net/rpc.Accept
::
func(lis net.Listener)
net/rpc.HandleHTTP
::
func()
net/rpc/jsonrpc.NewClientCodec
::
func(conn io.ReadWriteCloser) net/rpc.ClientCodec
net/rpc/jsonrpc.NewClient
::
func(conn io.ReadWriteCloser) *net/rpc.Client
net/rpc/jsonrpc.Dial
::
func(network string, address string) (*net/rpc.Client, error)
net/rpc/jsonrpc.NewServerCodec
::
func(conn io.ReadWriteCloser) net/rpc.ServerCodec
net/rpc/jsonrpc.ServeConn
::
func(conn io.ReadWriteCloser)
net/smtp.PlainAuth
::
func(identity string, username string, password string, host string) net/smtp.Auth
net/smtp.CRAMMD5Auth
::
func(username string, secret string) net/smtp.Auth
net/smtp.Dial
::
func(addr string) (*net/smtp.Client, error)
net/smtp.NewClient
::
func(conn net.Conn, host string) (*net/smtp.Client, error)
net/smtp.SendMail
::
func(addr string, a net/smtp.Auth, from string, to []string, msg []byte) error
os/exec/internal/fdtest.Exists
::
func(fd uintptr) bool
os/signal.Ignore
::
func(sig ...os.Signal)
os/signal.Ignored
::
func(sig os.Signal) bool
os/signal.Notify
::
func(c chan<- os.Signal, sig ...os.Signal)
os/signal.Reset
::
func(sig ...os.Signal)
os/signal.Stop
::
func(c chan<- os.Signal)
os/signal.NotifyContext
::
func(parent context.Context, signals ...os.Signal) (ctx context.Context, stop context.CancelFunc)
plugin.Open
::
func(path string) (*plugin.Plugin, error)
runtime/coverage.WriteMetaDir
::
func(dir string) error
runtime/coverage.WriteMeta
::
func(w io.Writer) error
runtime/coverage.WriteCountersDir
::
func(dir string) error
runtime/coverage.WriteCounters
::
func(w io.Writer) error
runtime/coverage.ClearCounters
::
func() error
runtime/internal/startlinetest.AsmFunc
::
func() int
runtime/metrics.All
::
func() []runtime/metrics.Description
runtime/metrics.Read
::
func(m []runtime/metrics.Sample)
testing/iotest.NewWriteLogger
::
func(prefix string, w io.Writer) io.Writer
testing/iotest.NewReadLogger
::
func(prefix string, r io.Reader) io.Reader
testing/iotest.OneByteReader
::
func(r io.Reader) io.Reader
testing/iotest.HalfReader
::
func(r io.Reader) io.Reader
testing/iotest.DataErrReader
::
func(r io.Reader) io.Reader
testing/iotest.TimeoutReader
::
func(r io.Reader) io.Reader
testing/iotest.ErrReader
::
func(err error) io.Reader
testing/iotest.TestReader
::
func(r io.Reader, content []byte) error
testing/iotest.TruncateWriter
::
func(w io.Writer, n int64) io.Writer
testing/fstest.TestFS
::
func(fsys io/fs.FS, expected ...string) error
testing/quick.Value
::
func(t reflect.Type, rand *math/rand.Rand) (value reflect.Value, ok bool)
testing/quick.Check
::
func(f any, config *testing/quick.Config) error
testing/quick.CheckEqual
::
func(f any, g any, config *testing/quick.Config) error
testing/slogtest.TestHandler
::
func(h log/slog.Handler, results func() []map[string]any) error
testing/slogtest.Run
::
func(t *testing.T, newHandler func(*testing.T) log/slog.Handler, result func(*testing.T) map[string]any)
vendor/golang.org/x/net/nettest.TestConn
::
func(t *testing.T, mp vendor/golang.org/x/net/nettest.MakePipe)
vendor/golang.org/x/net/nettest.SupportsIPv4
::
func() bool
vendor/golang.org/x/net/nettest.SupportsIPv6
::
func() bool
vendor/golang.org/x/net/nettest.SupportsRawSocket
::
func() bool
vendor/golang.org/x/net/nettest.TestableNetwork
::
func(network string) bool
vendor/golang.org/x/net/nettest.TestableAddress
::
func(network string, address string) bool
vendor/golang.org/x/net/nettest.NewLocalListener
::
func(network string) (net.Listener, error)
vendor/golang.org/x/net/nettest.NewLocalPacketListener
::
func(network string) (net.PacketConn, error)
vendor/golang.org/x/net/nettest.LocalPath
::
func() (string, error)
vendor/golang.org/x/net/nettest.MulticastSource
::
func(network string, ifi *net.Interface) (net.IP, error)
vendor/golang.org/x/net/nettest.LoopbackInterface
::
func() (*net.Interface, error)
vendor/golang.org/x/net/nettest.RoutedInterface
::
func(network string, flags net.Flags) (*net.Interface, error)