github.com/samber/lo.Map ::
func[T, R any](collection []T, iteratee func(item T, index int) R) []R
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.ITabTypeOff ::
func(ptrSize int) int
internal/abi.NoEscape ::
func(p unsafe.Pointer) unsafe.Pointer
internal/abi.Escape ::
func[T any](x T) T
internal/abi.FuncPCABI0 ::
func(f interface{}) uintptr
internal/abi.FuncPCABIInternal ::
func(f interface{}) uintptr
internal/abi.UseInterfaceSwitchCache ::
func(goarch string) bool
internal/abi.TypeOf ::
func(a any) *internal/abi.Type
internal/abi.TypeFor ::
func[T any]() *internal/abi.Type
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.CompareString ::
func(a string, b string) 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/byteorder.LeUint16 ::
func(b []byte) uint16
internal/byteorder.LePutUint16 ::
func(b []byte, v uint16)
internal/byteorder.LeAppendUint16 ::
func(b []byte, v uint16) []byte
internal/byteorder.LeUint32 ::
func(b []byte) uint32
internal/byteorder.LePutUint32 ::
func(b []byte, v uint32)
internal/byteorder.LeAppendUint32 ::
func(b []byte, v uint32) []byte
internal/byteorder.LeUint64 ::
func(b []byte) uint64
internal/byteorder.LePutUint64 ::
func(b []byte, v uint64)
internal/byteorder.LeAppendUint64 ::
func(b []byte, v uint64) []byte
internal/byteorder.BeUint16 ::
func(b []byte) uint16
internal/byteorder.BePutUint16 ::
func(b []byte, v uint16)
internal/byteorder.BeAppendUint16 ::
func(b []byte, v uint16) []byte
internal/byteorder.BeUint32 ::
func(b []byte) uint32
internal/byteorder.BePutUint32 ::
func(b []byte, v uint32)
internal/byteorder.BeAppendUint32 ::
func(b []byte, v uint32) []byte
internal/byteorder.BeUint64 ::
func(b []byte) uint64
internal/byteorder.BePutUint64 ::
func(b []byte, v uint64)
internal/byteorder.BeAppendUint64 ::
func(b []byte, v uint64) []byte
internal/chacha8rand.Marshal ::
func(s *internal/chacha8rand.State) []byte
internal/chacha8rand.Unmarshal ::
func(s *internal/chacha8rand.State, data []byte) error
internal/coverage/rtcov.AddMeta ::
func(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32
internal/godebugs.Lookup ::
func(name string) *internal/godebugs.Info
internal/runtime/atomic.Load ::
func(ptr *uint32) uint32
internal/runtime/atomic.Loadp ::
func(ptr unsafe.Pointer) unsafe.Pointer
internal/runtime/atomic.Load64 ::
func(ptr *uint64) uint64
internal/runtime/atomic.LoadAcq ::
func(ptr *uint32) uint32
internal/runtime/atomic.LoadAcq64 ::
func(ptr *uint64) uint64
internal/runtime/atomic.LoadAcquintptr ::
func(ptr *uintptr) uintptr
internal/runtime/atomic.Xadd ::
func(ptr *uint32, delta int32) uint32
internal/runtime/atomic.Xadd64 ::
func(ptr *uint64, delta int64) uint64
internal/runtime/atomic.Xadduintptr ::
func(ptr *uintptr, delta uintptr) uintptr
internal/runtime/atomic.Xchg ::
func(ptr *uint32, new uint32) uint32
internal/runtime/atomic.Xchg64 ::
func(ptr *uint64, new uint64) uint64
internal/runtime/atomic.Xchguintptr ::
func(ptr *uintptr, new uintptr) uintptr
internal/runtime/atomic.Load8 ::
func(ptr *uint8) uint8
internal/runtime/atomic.And8 ::
func(ptr *uint8, val uint8)
internal/runtime/atomic.Or8 ::
func(ptr *uint8, val uint8)
internal/runtime/atomic.And ::
func(ptr *uint32, val uint32)
internal/runtime/atomic.Or ::
func(ptr *uint32, val uint32)
internal/runtime/atomic.And32 ::
func(ptr *uint32, val uint32) uint32
internal/runtime/atomic.Or32 ::
func(ptr *uint32, val uint32) uint32
internal/runtime/atomic.And64 ::
func(ptr *uint64, val uint64) uint64
internal/runtime/atomic.Or64 ::
func(ptr *uint64, val uint64) uint64
internal/runtime/atomic.Anduintptr ::
func(ptr *uintptr, val uintptr) uintptr
internal/runtime/atomic.Oruintptr ::
func(ptr *uintptr, val uintptr) uintptr
internal/runtime/atomic.Cas64 ::
func(ptr *uint64, old uint64, new uint64) bool
internal/runtime/atomic.CasRel ::
func(ptr *uint32, old uint32, new uint32) bool
internal/runtime/atomic.Store ::
func(ptr *uint32, val uint32)
internal/runtime/atomic.Store8 ::
func(ptr *uint8, val uint8)
internal/runtime/atomic.Store64 ::
func(ptr *uint64, val uint64)
internal/runtime/atomic.StoreRel ::
func(ptr *uint32, val uint32)
internal/runtime/atomic.StoreRel64 ::
func(ptr *uint64, val uint64)
internal/runtime/atomic.StoreReluintptr ::
func(ptr *uintptr, val uintptr)
internal/runtime/atomic.StorepNoWB ::
func(ptr unsafe.Pointer, val unsafe.Pointer)
internal/runtime/atomic.Cas ::
func(ptr *uint32, old uint32, new uint32) bool
internal/runtime/atomic.Casp1 ::
func(ptr *unsafe.Pointer, old unsafe.Pointer, new unsafe.Pointer) bool
internal/runtime/atomic.Casint32 ::
func(ptr *int32, old int32, new int32) bool
internal/runtime/atomic.Casint64 ::
func(ptr *int64, old int64, new int64) bool
internal/runtime/atomic.Casuintptr ::
func(ptr *uintptr, old uintptr, new uintptr) bool
internal/runtime/atomic.Storeint32 ::
func(ptr *int32, new int32)
internal/runtime/atomic.Storeint64 ::
func(ptr *int64, new int64)
internal/runtime/atomic.Storeuintptr ::
func(ptr *uintptr, new uintptr)
internal/runtime/atomic.Loaduintptr ::
func(ptr *uintptr) uintptr
internal/runtime/atomic.Loaduint ::
func(ptr *uint) uint
internal/runtime/atomic.Loadint32 ::
func(ptr *int32) int32
internal/runtime/atomic.Loadint64 ::
func(ptr *int64) int64
internal/runtime/atomic.Xaddint32 ::
func(ptr *int32, delta int32) int32
internal/runtime/atomic.Xaddint64 ::
func(ptr *int64, delta int64) int64
internal/runtime/atomic.Xchgint32 ::
func(ptr *int32, new int32) int32
internal/runtime/atomic.Xchgint64 ::
func(ptr *int64, new int64) int64
internal/runtime/exithook.Add ::
func(h internal/runtime/exithook.Hook)
internal/runtime/exithook.Run ::
func(code int)
internal/runtime/syscall.Syscall6 ::
func(num uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, errno uintptr)
internal/runtime/syscall.EpollCreate1 ::
func(flags int32) (fd int32, errno uintptr)
internal/runtime/syscall.EpollWait ::
func(epfd int32, events []internal/runtime/syscall.EpollEvent, maxev int32, waitms int32) (n int32, errno uintptr)
internal/runtime/syscall.EpollCtl ::
func(epfd int32, op int32, fd int32, event *internal/runtime/syscall.EpollEvent) (errno uintptr)
internal/runtime/syscall.Eventfd ::
func(initval int32, flags int32) (fd int32, errno uintptr)
internal/stringslite.HasPrefix ::
func(s string, prefix string) bool
internal/stringslite.HasSuffix ::
func(s string, suffix string) bool
internal/stringslite.IndexByte ::
func(s string, c byte) int
internal/stringslite.Index ::
func(s string, substr string) int
internal/stringslite.Cut ::
func(s string, sep string) (before string, after string, found bool)
internal/stringslite.CutPrefix ::
func(s string, prefix string) (after string, found bool)
internal/stringslite.CutSuffix ::
func(s string, suffix string) (before string, found bool)
internal/stringslite.TrimPrefix ::
func(s string, prefix string) string
internal/stringslite.TrimSuffix ::
func(s string, suffix string) string
internal/stringslite.Clone ::
func(s string) string
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.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/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.AndInt32 ::
func(addr *int32, mask int32) (old int32)
sync/atomic.AndUint32 ::
func(addr *uint32, mask uint32) (old uint32)
sync/atomic.AndInt64 ::
func(addr *int64, mask int64) (old int64)
sync/atomic.AndUint64 ::
func(addr *uint64, mask uint64) (old uint64)
sync/atomic.AndUintptr ::
func(addr *uintptr, mask uintptr) (old uintptr)
sync/atomic.OrInt32 ::
func(addr *int32, mask int32) (old int32)
sync/atomic.OrUint32 ::
func(addr *uint32, mask uint32) (old uint32)
sync/atomic.OrInt64 ::
func(addr *int64, mask int64) (old int64)
sync/atomic.OrUint64 ::
func(addr *uint64, mask uint64) (old uint64)
sync/atomic.OrUintptr ::
func(addr *uintptr, mask uintptr) (old 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)
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)
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
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
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
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
internal/itoa.Itoa ::
func(val int) string
internal/itoa.Uitoa ::
func(val uint) string
internal/itoa.Uitox ::
func(val uint) string
iter.Pull ::
func[V any](seq iter.Seq[V]) (next func() (V, bool), stop func())
iter.Pull2 ::
func[K, V any](seq iter.Seq2[K, V]) (next func() (K, V, bool), stop func())
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
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
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
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.SliceAt ::
func(typ reflect.Type, p unsafe.Pointer, n 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
slices.All ::
func[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]
slices.Backward ::
func[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]
slices.Values ::
func[Slice ~[]E, E any](s Slice) iter.Seq[E]
slices.AppendSeq ::
func[Slice ~[]E, E any](s Slice, seq iter.Seq[E]) Slice
slices.Collect ::
func[E any](seq iter.Seq[E]) []E
slices.Sorted ::
func[E cmp.Ordered](seq iter.Seq[E]) []E
slices.SortedFunc ::
func[E any](seq iter.Seq[E], cmp func(E, E) int) []E
slices.SortedStableFunc ::
func[E any](seq iter.Seq[E], cmp func(E, E) int) []E
slices.Chunk ::
func[Slice ~[]E, E any](s Slice, n int) iter.Seq[Slice]
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.Repeat ::
func[S ~[]E, E any](x S, count int) 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)
internal/fmtsort.Sort ::
func(mapValue reflect.Value) internal/fmtsort.SortedMap
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
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
internal/asan.Read ::
func(addr unsafe.Pointer, len uintptr)
internal/asan.Write ::
func(addr unsafe.Pointer, len uintptr)
internal/msan.Read ::
func(addr unsafe.Pointer, sz uintptr)
internal/msan.Write ::
func(addr unsafe.Pointer, sz uintptr)
internal/msan.Malloc ::
func(addr unsafe.Pointer, sz uintptr)
internal/msan.Free ::
func(addr unsafe.Pointer, sz uintptr)
internal/msan.Move ::
func(dst unsafe.Pointer, src unsafe.Pointer, sz uintptr)
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.RawSyscall ::
func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err syscall.Errno)
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.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)
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)
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
internal/filepathlite.Clean ::
func(path string) string
internal/filepathlite.IsLocal ::
func(path string) bool
internal/filepathlite.Localize ::
func(path string) (string, error)
internal/filepathlite.ToSlash ::
func(path string) string
internal/filepathlite.FromSlash ::
func(path string) string
internal/filepathlite.Split ::
func(path string) (dir string, file string)
internal/filepathlite.Ext ::
func(path string) string
internal/filepathlite.Base ::
func(path string) string
internal/filepathlite.Dir ::
func(path string) string
internal/filepathlite.VolumeName ::
func(path string) string
internal/filepathlite.VolumeNameLen ::
func(path string) int
internal/filepathlite.IsPathSeparator ::
func(c uint8) bool
internal/filepathlite.IsAbs ::
func(path string) bool
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
internal/syscall/unix.PidFDOpen ::
func(pid int, flags int) (uintptr, error)
internal/syscall/unix.Tcsetpgrp ::
func(fd int, pgid int32) (err 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) (written int64, err error, handled bool)
internal/poll.Splice ::
func(dst *internal/poll.FD, src *internal/poll.FD, remain int64) (written int64, handled bool, err 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)
os.ReadDir ::
func(name string) ([]io/fs.DirEntry, error)
os.CopyFS ::
func(dir string, fsys io/fs.FS) 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)
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)
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.Localize ::
func(path string) (string, error)
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.IsAbs ::
func(path string) bool
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.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
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)
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.Decode ::
func(buf []byte, order encoding/binary.ByteOrder, data any) (int, error)
encoding/binary.Write ::
func(w io.Writer, order encoding/binary.ByteOrder, data any) error
encoding/binary.Encode ::
func(buf []byte, order encoding/binary.ByteOrder, data any) (int, error)
encoding/binary.Append ::
func(buf []byte, order encoding/binary.ByteOrder, data any) ([]byte, 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/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
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.RuneLen ::
func(r rune) int
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
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
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
runtime/debug.SetCrashOutput ::
func(f *os.File, opts runtime/debug.CrashOptions) error
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)
crypto/internal/cryptotest.TestHash ::
func(t *testing.T, mh crypto/internal/cryptotest.MakeHash)
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/internal/hpke.SetupSender ::
func(kemID uint16, kdfID uint16, aeadID uint16, pub crypto.PublicKey, info []byte) ([]byte, *crypto/internal/hpke.Sender, error)
crypto/internal/hpke.SuiteID ::
func(kemID uint16, kdfID uint16, aeadID uint16) []byte
crypto/internal/hpke.ParseHPKEPublicKey ::
func(kemID uint16, bytes []byte) (*crypto/ecdh.PublicKey, error)
vendor/golang.org/x/crypto/sha3.New224 ::
func() hash.Hash
vendor/golang.org/x/crypto/sha3.New256 ::
func() hash.Hash
vendor/golang.org/x/crypto/sha3.New384 ::
func() hash.Hash
vendor/golang.org/x/crypto/sha3.New512 ::
func() hash.Hash
vendor/golang.org/x/crypto/sha3.NewLegacyKeccak256 ::
func() hash.Hash
vendor/golang.org/x/crypto/sha3.NewLegacyKeccak512 ::
func() hash.Hash
vendor/golang.org/x/crypto/sha3.Sum224 ::
func(data []byte) (digest [28]byte)
vendor/golang.org/x/crypto/sha3.Sum256 ::
func(data []byte) (digest [32]byte)
vendor/golang.org/x/crypto/sha3.Sum384 ::
func(data []byte) (digest [48]byte)
vendor/golang.org/x/crypto/sha3.Sum512 ::
func(data []byte) (digest [64]byte)
vendor/golang.org/x/crypto/sha3.NewShake128 ::
func() vendor/golang.org/x/crypto/sha3.ShakeHash
vendor/golang.org/x/crypto/sha3.NewShake256 ::
func() vendor/golang.org/x/crypto/sha3.ShakeHash
vendor/golang.org/x/crypto/sha3.NewCShake128 ::
func(N []byte, S []byte) vendor/golang.org/x/crypto/sha3.ShakeHash
vendor/golang.org/x/crypto/sha3.NewCShake256 ::
func(N []byte, S []byte) vendor/golang.org/x/crypto/sha3.ShakeHash
vendor/golang.org/x/crypto/sha3.ShakeSum128 ::
func(hash []byte, data []byte)
vendor/golang.org/x/crypto/sha3.ShakeSum256 ::
func(hash []byte, data []byte)
crypto/internal/mlkem768.GenerateKey ::
func() (*crypto/internal/mlkem768.DecapsulationKey, error)
crypto/internal/mlkem768.NewKeyFromSeed ::
func(seed []byte) (*crypto/internal/mlkem768.DecapsulationKey, error)
crypto/internal/mlkem768.NewKeyFromExtendedEncoding ::
func(decapsulationKey []byte) (*crypto/internal/mlkem768.DecapsulationKey, error)
crypto/internal/mlkem768.Encapsulate ::
func(encapsulationKey []byte) (ciphertext []byte, sharedKey []byte, err error)
crypto/internal/mlkem768.Decapsulate ::
func(dk *crypto/internal/mlkem768.DecapsulationKey, ciphertext []byte) (sharedKey []byte, err error)
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
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.Uint ::
func() uint
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
internal/concurrent.NewHashTrieMap ::
func[K, V comparable]() *internal/concurrent.HashTrieMap[K, V]
internal/weak.Make ::
func[T any](ptr *T) internal/weak.Pointer[T]
unique.Make ::
func[T comparable](value T) unique.Handle[T]
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.ParseOID ::
func(oid string) (crypto/x509.OID, 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)
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)
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
maps.All ::
func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V]
maps.Keys ::
func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K]
maps.Values ::
func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V]
maps.Insert ::
func[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V])
maps.Collect ::
func[K comparable, V any](seq iter.Seq2[K, V]) map[K]V
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)
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.ParseCookie ::
func(line string) ([]*net/http.Cookie, error)
net/http.ParseSetCookie ::
func(line string) (*net/http.Cookie, 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
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/ast.Preorder ::
func(root go/ast.Node) iter.Seq[go/ast.Node]
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.ParseGoarm64 ::
func(v string) (g internal/buildcfg.Goarm64Features, e error)
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/coverage/cfile.WriteMetaDir ::
func(dir string) error
internal/coverage/cfile.WriteMeta ::
func(w io.Writer) error
internal/coverage/cfile.WriteCountersDir ::
func(dir string) error
internal/coverage/cfile.WriteCounters ::
func(w io.Writer) error
internal/coverage/cfile.ClearCounters ::
func() error
internal/coverage/cfile.MarkProfileEmitted ::
func(val bool)
internal/coverage/cfile.InitHook ::
func(istest bool)
internal/coverage/cfile.ProcessCoverTestDir ::
func(dir string, cfile string, cm string, cpkg string, w io.Writer, selpkgs []string) error
internal/coverage/cfile.Snapshot ::
func() float64
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.NewGraph ::
func(prof *internal/profile.Profile, o *internal/profile.Options) *internal/profile.Graph
internal/profile.CreateNodes ::
func(prof *internal/profile.Profile, o *internal/profile.Options) (internal/profile.Nodes, internal/profile.locationMap)
internal/profile.Merge ::
func(srcs []*internal/profile.Profile) (*internal/profile.Profile, error)
internal/profile.Parse ::
func(r io.Reader) (*internal/profile.Profile, error)
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.MustInternalLinkPIE ::
func(t testing.TB)
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/testenv.ParallelOn64Bit ::
func(t *testing.T)
internal/testpty.Open ::
func() (pty *os.File, processTTY string, err error)
internal/trace/event.Names ::
func(specs []internal/trace/event.Spec) map[string]internal/trace/event.Type
internal/trace/event/go122.EventString ::
func(typ internal/trace/event.Type) string
internal/trace/event/go122.Specs ::
func() []internal/trace/event.Spec
internal/trace/version.ReadHeader ::
func(r io.Reader) (internal/trace/version.Version, error)
internal/trace/version.WriteHeader ::
func(w io.Writer, v internal/trace/version.Version) (int, error)
internal/trace/internal/oldtrace.Parse ::
func(r io.Reader, vers internal/trace/version.Version) (internal/trace/internal/oldtrace.Trace, error)
internal/trace.MutatorUtilizationV2 ::
func(events []internal/trace.Event, flags internal/trace.UtilFlags) [][]internal/trace.MutatorUtil
internal/trace.NewMMUCurve ::
func(utils [][]internal/trace.MutatorUtil) *internal/trace.MMUCurve
internal/trace.NewReader ::
func(r io.Reader) (*internal/trace.Reader, error)
internal/trace.MakeResourceID ::
func[T interface{internal/trace.GoID | internal/trace.ProcID | internal/trace.ThreadID}](id T) internal/trace.ResourceID
internal/trace.NewSummarizer ::
func() *internal/trace.Summarizer
internal/trace.RelatedGoroutinesV2 ::
func(events []internal/trace.Event, goid internal/trace.GoID) map[internal/trace.GoID]struct{}
internal/trace.IsSystemGoroutine ::
func(entryFn string) bool
internal/trace/raw.NewReader ::
func(r io.Reader) (*internal/trace/raw.Reader, error)
internal/trace/raw.NewTextReader ::
func(r io.Reader) (*internal/trace/raw.TextReader, error)
internal/trace/raw.NewTextWriter ::
func(w io.Writer, v internal/trace/version.Version) (*internal/trace/raw.TextWriter, error)
internal/trace/raw.NewWriter ::
func(w io.Writer, v internal/trace/version.Version) (*internal/trace/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/internal/testgen/go122.Main ::
func(f func(*internal/trace/internal/testgen/go122.Trace))
internal/trace/internal/testgen/go122.NewTrace ::
func() *internal/trace/internal/testgen/go122.Trace
internal/trace/testtrace.ExpectSuccess ::
func() *internal/trace/testtrace.Expectation
internal/trace/testtrace.ParseExpectation ::
func(data []byte) (*internal/trace/testtrace.Expectation, error)
internal/trace/testtrace.ParseFile ::
func(testPath string) (io.Reader, *internal/trace/testtrace.Expectation, error)
internal/trace/testtrace.NewValidator ::
func() *internal/trace/testtrace.Validator
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
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)
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
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.NewRequestWithContext ::
func(ctx context.Context, 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)
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.Async ::
func[A any](f func() A) <-chan A
github.com/samber/lo.Async0 ::
func(f func()) <-chan struct{}
github.com/samber/lo.Async1 ::
func[A any](f func() A) <-chan A
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.WaitFor ::
func(condition func(i int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool)
github.com/samber/lo.WaitForWithContext ::
func(ctx context.Context, condition func(ctx context.Context, currentIteration int) bool, timeout time.Duration, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool)
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 ...any) T
github.com/samber/lo.Must0 ::
func(err any, messageArgs ...any)
github.com/samber/lo.Must1 ::
func[T any](val T, err any, messageArgs ...any) T
github.com/samber/lo.Must2 ::
func[T1, T2 any](val1 T1, val2 T2, err any, messageArgs ...any) (T1, T2)
github.com/samber/lo.Must3 ::
func[T1, T2, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...any) (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 ...any) (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 ...any) (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 ...any) (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, Slice ~[]T](collection Slice) Slice
github.com/samber/lo.FindUniquesBy ::
func[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
github.com/samber/lo.FindDuplicates ::
func[T comparable, Slice ~[]T](collection Slice) Slice
github.com/samber/lo.FindDuplicatesBy ::
func[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
github.com/samber/lo.Min ::
func[T cmp.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.Earliest ::
func(times ...time.Time) time.Time
github.com/samber/lo.EarliestBy ::
func[T any](collection []T, iteratee func(item T) time.Time) T
github.com/samber/lo.Max ::
func[T cmp.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.Latest ::
func(times ...time.Time) time.Time
github.com/samber/lo.LatestBy ::
func[T any](collection []T, iteratee func(item T) time.Time) T
github.com/samber/lo.First ::
func[T any](collection []T) (T, bool)
github.com/samber/lo.FirstOrEmpty ::
func[T any](collection []T) T
github.com/samber/lo.FirstOr ::
func[T any](collection []T, fallback T) T
github.com/samber/lo.Last ::
func[T any](collection []T) (T, bool)
github.com/samber/lo.LastOrEmpty ::
func[T any](collection []T) T
github.com/samber/lo.LastOr ::
func[T any](collection []T, fallback T) T
github.com/samber/lo.Nth ::
func[T any, N github.com/samber/lo/internal/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, Slice ~[]T](collection Slice, count int) Slice
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, Slice ~[]T](list1 Slice, list2 Slice) Slice
github.com/samber/lo.Difference ::
func[T comparable, Slice ~[]T](list1 Slice, list2 Slice) (Slice, Slice)
github.com/samber/lo.Union ::
func[T comparable, Slice ~[]T](lists ...Slice) Slice
github.com/samber/lo.Without ::
func[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice
github.com/samber/lo.WithoutEmpty ::
func[T comparable, Slice ~[]T](collection Slice) Slice
github.com/samber/lo.Keys ::
func[K comparable, V any](in ...map[K]V) []K
github.com/samber/lo.UniqKeys ::
func[K comparable, V any](in ...map[K]V) []K
github.com/samber/lo.HasKey ::
func[K comparable, V any](in map[K]V, key K) bool
github.com/samber/lo.Values ::
func[K comparable, V any](in ...map[K]V) []V
github.com/samber/lo.UniqValues ::
func[K, V comparable](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, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map
github.com/samber/lo.PickByKeys ::
func[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map
github.com/samber/lo.PickByValues ::
func[K, V comparable, Map ~map[K]V](in Map, values []V) Map
github.com/samber/lo.OmitBy ::
func[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map
github.com/samber/lo.OmitByKeys ::
func[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map
github.com/samber/lo.OmitByValues ::
func[K, V comparable, Map ~map[K]V](in Map, values []V) Map
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, Map ~map[K]V](maps ...Map) Map
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 github.com/samber/lo/internal/constraints.Integer | github.com/samber/lo/internal/constraints.Float](start T, elementNum int) []T
github.com/samber/lo.RangeWithSteps ::
func[T github.com/samber/lo/internal/constraints.Integer | github.com/samber/lo/internal/constraints.Float](start T, end T, step T) []T
github.com/samber/lo.Clamp ::
func[T cmp.Ordered](value T, min T, max T) T
github.com/samber/lo.Sum ::
func[T github.com/samber/lo/internal/constraints.Float | github.com/samber/lo/internal/constraints.Integer | github.com/samber/lo/internal/constraints.Complex](collection []T) T
github.com/samber/lo.SumBy ::
func[T any, R github.com/samber/lo/internal/constraints.Float | github.com/samber/lo/internal/constraints.Integer | github.com/samber/lo/internal/constraints.Complex](collection []T, iteratee func(item T) R) R
github.com/samber/lo.Mean ::
func[T github.com/samber/lo/internal/constraints.Float | github.com/samber/lo/internal/constraints.Integer](collection []T) T
github.com/samber/lo.MeanBy ::
func[T any, R github.com/samber/lo/internal/constraints.Float | github.com/samber/lo/internal/constraints.Integer](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[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice
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.ForEachWhile ::
func[T any](collection []T, iteratee func(item T, index int) (goon bool))
github.com/samber/lo.Times ::
func[T any](count int, iteratee func(index int) T) []T
github.com/samber/lo.Uniq ::
func[T comparable, Slice ~[]T](collection Slice) Slice
github.com/samber/lo.UniqBy ::
func[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice
github.com/samber/lo.GroupBy ::
func[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) map[U]Slice
github.com/samber/lo.Chunk ::
func[T any, Slice ~[]T](collection Slice, size int) []Slice
github.com/samber/lo.PartitionBy ::
func[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K) []Slice
github.com/samber/lo.Flatten ::
func[T any, Slice ~[]T](collection []Slice) Slice
github.com/samber/lo.Interleave ::
func[T any, Slice ~[]T](collections ...Slice) Slice
github.com/samber/lo.Shuffle ::
func[T any, Slice ~[]T](collection Slice) Slice
github.com/samber/lo.Reverse ::
func[T any, Slice ~[]T](collection Slice) Slice
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, Slice ~[]T](collection Slice, n int) Slice
github.com/samber/lo.DropRight ::
func[T any, Slice ~[]T](collection Slice, n int) Slice
github.com/samber/lo.DropWhile ::
func[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice
github.com/samber/lo.DropRightWhile ::
func[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice
github.com/samber/lo.DropByIndex ::
func[T any](collection []T, indexes ...int) []T
github.com/samber/lo.Reject ::
func[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice
github.com/samber/lo.RejectMap ::
func[T, R any](collection []T, callback func(item T, index int) (R, bool)) []R
github.com/samber/lo.FilterReject ::
func[T any, Slice ~[]T](collection Slice, predicate func(T, int) bool) (kept Slice, rejected Slice)
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, Slice ~[]T](collection Slice, offset int, length uint) Slice
github.com/samber/lo.Slice ::
func[T any, Slice ~[]T](collection Slice, start int, end int) Slice
github.com/samber/lo.Replace ::
func[T comparable, Slice ~[]T](collection Slice, old T, new T, n int) Slice
github.com/samber/lo.ReplaceAll ::
func[T comparable, Slice ~[]T](collection Slice, old T, new T) Slice
github.com/samber/lo.Compact ::
func[T comparable, Slice ~[]T](collection Slice) Slice
github.com/samber/lo.IsSorted ::
func[T cmp.Ordered](collection []T) bool
github.com/samber/lo.IsSortedByKey ::
func[T any, K cmp.Ordered](collection []T, iteratee func(item T) K) bool
github.com/samber/lo.Splice ::
func[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice
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.PascalCase ::
func(str string) string
github.com/samber/lo.CamelCase ::
func(str string) string
github.com/samber/lo.KebabCase ::
func(str string) string
github.com/samber/lo.SnakeCase ::
func(str string) string
github.com/samber/lo.Words ::
func(str string) []string
github.com/samber/lo.Capitalize ::
func(str string) string
github.com/samber/lo.Elipse ::
func(str string, length int) string
github.com/samber/lo.Duration ::
func(cb func()) time.Duration
github.com/samber/lo.Duration0 ::
func(cb func()) time.Duration
github.com/samber/lo.Duration1 ::
func[A any](cb func() A) (A, time.Duration)
github.com/samber/lo.Duration2 ::
func[A, B any](cb func() (A, B)) (A, B, time.Duration)
github.com/samber/lo.Duration3 ::
func[A, B, C any](cb func() (A, B, C)) (A, B, C, time.Duration)
github.com/samber/lo.Duration4 ::
func[A, B, C, D any](cb func() (A, B, C, D)) (A, B, C, D, time.Duration)
github.com/samber/lo.Duration5 ::
func[A, B, C, D, E any](cb func() (A, B, C, D, E)) (A, B, C, D, E, time.Duration)
github.com/samber/lo.Duration6 ::
func[A, B, C, D, E, F any](cb func() (A, B, C, D, E, F)) (A, B, C, D, E, F, time.Duration)
github.com/samber/lo.Duration7 ::
func[A, B, C, D, E, F, G any](cb func() (A, B, C, D, E, F, G)) (A, B, C, D, E, F, G, time.Duration)
github.com/samber/lo.Duration8 ::
func[A, B, C, D, E, F, G, H any](cb func() (A, B, C, D, E, F, G, H)) (A, B, C, D, E, F, G, H, time.Duration)
github.com/samber/lo.Duration9 ::
func[A, B, C, D, E, F, G, H, I any](cb func() (A, B, C, D, E, F, G, H, I)) (A, B, C, D, E, F, G, H, I, time.Duration)
github.com/samber/lo.Duration10 ::
func[A, B, C, D, E, F, G, H, I, J any](cb func() (A, B, C, D, E, F, G, H, I, J)) (A, B, C, D, E, F, G, H, I, J, time.Duration)
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.ZipBy2 ::
func[A, B, Out any](a []A, b []B, iteratee func(a A, b B) Out) []Out
github.com/samber/lo.ZipBy3 ::
func[A, B, C, Out any](a []A, b []B, c []C, iteratee func(a A, b B, c C) Out) []Out
github.com/samber/lo.ZipBy4 ::
func[A, B, C, D, Out any](a []A, b []B, c []C, d []D, iteratee func(a A, b B, c C, d D) Out) []Out
github.com/samber/lo.ZipBy5 ::
func[A, B, C, D, E, Out any](a []A, b []B, c []C, d []D, e []E, iteratee func(a A, b B, c C, d D, e E) Out) []Out
github.com/samber/lo.ZipBy6 ::
func[A, B, C, D, E, F, Out any](a []A, b []B, c []C, d []D, e []E, f []F, iteratee func(a A, b B, c C, d D, e E, f F) Out) []Out
github.com/samber/lo.ZipBy7 ::
func[A, B, C, D, E, F, G, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, iteratee func(a A, b B, c C, d D, e E, f F, g G) Out) []Out
github.com/samber/lo.ZipBy8 ::
func[A, B, C, D, E, F, G, H, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H) Out) []Out
github.com/samber/lo.ZipBy9 ::
func[A, B, C, D, E, F, G, H, I, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H, i I) Out) []Out
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.UnzipBy2 ::
func[In, A, B any](items []In, iteratee func(In) (a A, b B)) ([]A, []B)
github.com/samber/lo.UnzipBy3 ::
func[In, A, B, C any](items []In, iteratee func(In) (a A, b B, c C)) ([]A, []B, []C)
github.com/samber/lo.UnzipBy4 ::
func[In, A, B, C, D any](items []In, iteratee func(In) (a A, b B, c C, d D)) ([]A, []B, []C, []D)
github.com/samber/lo.UnzipBy5 ::
func[In, A, B, C, D, E any](items []In, iteratee func(In) (a A, b B, c C, d D, e E)) ([]A, []B, []C, []D, []E)
github.com/samber/lo.UnzipBy6 ::
func[In, A, B, C, D, E, F any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F)) ([]A, []B, []C, []D, []E, []F)
github.com/samber/lo.UnzipBy7 ::
func[In, A, B, C, D, E, F, G any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G)) ([]A, []B, []C, []D, []E, []F, []G)
github.com/samber/lo.UnzipBy8 ::
func[In, A, B, C, D, E, F, G, H any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H)) ([]A, []B, []C, []D, []E, []F, []G, []H)
github.com/samber/lo.UnzipBy9 ::
func[In, A, B, C, D, E, F, G, H, I any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H, i I)) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
github.com/samber/lo.IsNil ::
func(x any) bool
github.com/samber/lo.ToPtr ::
func[T any](x T) *T
github.com/samber/lo.Nil ::
func[T any]() *T
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.FromSlicePtr ::
func[T any](collection []*T) []T
github.com/samber/lo.FromSlicePtrOr ::
func[T any](collection []*T, fallback 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](values ...T) (result T, ok bool)
github.com/samber/lo.CoalesceOrEmpty ::
func[T comparable](v ...T) T
github.com/samber/mo.Do ::
func[T any](fn func() T) (result github.com/samber/mo.Result[T])
github.com/samber/mo.Left ::
func[L, R any](value L) github.com/samber/mo.Either[L, R]
github.com/samber/mo.Right ::
func[L, R any](value R) github.com/samber/mo.Either[L, R]
github.com/samber/mo.NewEither3Arg1 ::
func[T1, T2, T3 any](value T1) github.com/samber/mo.Either3[T1, T2, T3]
github.com/samber/mo.NewEither3Arg2 ::
func[T1, T2, T3 any](value T2) github.com/samber/mo.Either3[T1, T2, T3]
github.com/samber/mo.NewEither3Arg3 ::
func[T1, T2, T3 any](value T3) github.com/samber/mo.Either3[T1, T2, T3]
github.com/samber/mo.NewEither4Arg1 ::
func[T1, T2, T3, T4 any](value T1) github.com/samber/mo.Either4[T1, T2, T3, T4]
github.com/samber/mo.NewEither4Arg2 ::
func[T1, T2, T3, T4 any](value T2) github.com/samber/mo.Either4[T1, T2, T3, T4]
github.com/samber/mo.NewEither4Arg3 ::
func[T1, T2, T3, T4 any](value T3) github.com/samber/mo.Either4[T1, T2, T3, T4]
github.com/samber/mo.NewEither4Arg4 ::
func[T1, T2, T3, T4 any](value T4) github.com/samber/mo.Either4[T1, T2, T3, T4]
github.com/samber/mo.NewEither5Arg1 ::
func[T1, T2, T3, T4, T5 any](value T1) github.com/samber/mo.Either5[T1, T2, T3, T4, T5]
github.com/samber/mo.NewEither5Arg2 ::
func[T1, T2, T3, T4, T5 any](value T2) github.com/samber/mo.Either5[T1, T2, T3, T4, T5]
github.com/samber/mo.NewEither5Arg3 ::
func[T1, T2, T3, T4, T5 any](value T3) github.com/samber/mo.Either5[T1, T2, T3, T4, T5]
github.com/samber/mo.NewEither5Arg4 ::
func[T1, T2, T3, T4, T5 any](value T4) github.com/samber/mo.Either5[T1, T2, T3, T4, T5]
github.com/samber/mo.NewEither5Arg5 ::
func[T1, T2, T3, T4, T5 any](value T5) github.com/samber/mo.Either5[T1, T2, T3, T4, T5]
github.com/samber/mo.Fold ::
func[T, U, R any](f github.com/samber/mo.Foldable[T, U], successFunc func(U) R, failureFunc func(T) R) R
github.com/samber/mo.NewFuture ::
func[T any](cb func(resolve func(T), reject func(error))) *github.com/samber/mo.Future[T]
github.com/samber/mo.NewIO ::
func[R any](f github.com/samber/mo.f0[R]) github.com/samber/mo.IO[R]
github.com/samber/mo.NewIO1 ::
func[R, A any](f github.com/samber/mo.f1[R, A]) github.com/samber/mo.IO1[R, A]
github.com/samber/mo.NewIO2 ::
func[R, A, B any](f github.com/samber/mo.f2[R, A, B]) github.com/samber/mo.IO2[R, A, B]
github.com/samber/mo.NewIO3 ::
func[R, A, B, C any](f github.com/samber/mo.f3[R, A, B, C]) github.com/samber/mo.IO3[R, A, B, C]
github.com/samber/mo.NewIO4 ::
func[R, A, B, C, D any](f github.com/samber/mo.f4[R, A, B, C, D]) github.com/samber/mo.IO4[R, A, B, C, D]
github.com/samber/mo.NewIO5 ::
func[R, A, B, C, D, E any](f github.com/samber/mo.f5[R, A, B, C, D, E]) github.com/samber/mo.IO5[R, A, B, C, D, E]
github.com/samber/mo.NewIOEither ::
func[R any](f github.com/samber/mo.fe0[R]) github.com/samber/mo.IOEither[R]
github.com/samber/mo.NewIOEither1 ::
func[R, A any](f github.com/samber/mo.fe1[R, A]) github.com/samber/mo.IOEither1[R, A]
github.com/samber/mo.NewIOEither2 ::
func[R, A, B any](f github.com/samber/mo.fe2[R, A, B]) github.com/samber/mo.IOEither2[R, A, B]
github.com/samber/mo.NewIOEither3 ::
func[R, A, B, C any](f github.com/samber/mo.fe3[R, A, B, C]) github.com/samber/mo.IOEither3[R, A, B, C]
github.com/samber/mo.NewIOEither4 ::
func[R, A, B, C, D any](f github.com/samber/mo.fe4[R, A, B, C, D]) github.com/samber/mo.IOEither4[R, A, B, C, D]
github.com/samber/mo.NewIOEither5 ::
func[R, A, B, C, D, E any](f github.com/samber/mo.fe5[R, A, B, C, D, E]) github.com/samber/mo.IOEither5[R, A, B, C, D, E]
github.com/samber/mo.Some ::
func[T any](value T) github.com/samber/mo.Option[T]
github.com/samber/mo.None ::
func[T any]() github.com/samber/mo.Option[T]
github.com/samber/mo.TupleToOption ::
func[T any](value T, ok bool) github.com/samber/mo.Option[T]
github.com/samber/mo.EmptyableToOption ::
func[T any](value T) github.com/samber/mo.Option[T]
github.com/samber/mo.PointerToOption ::
func[T any](value *T) github.com/samber/mo.Option[T]
github.com/samber/mo.Ok ::
func[T any](value T) github.com/samber/mo.Result[T]
github.com/samber/mo.Err ::
func[T any](err error) github.com/samber/mo.Result[T]
github.com/samber/mo.Errf ::
func[T any](format string, a ...any) github.com/samber/mo.Result[T]
github.com/samber/mo.TupleToResult ::
func[T any](value T, err error) github.com/samber/mo.Result[T]
github.com/samber/mo.Try ::
func[T any](f func() (T, error)) github.com/samber/mo.Result[T]
github.com/samber/mo.NewState ::
func[S, A any](f func(state S) (A, S)) github.com/samber/mo.State[S, A]
github.com/samber/mo.ReturnState ::
func[S, A any](x A) github.com/samber/mo.State[S, A]
github.com/samber/mo.NewTask ::
func[R any](f github.com/samber/mo.ff0[R]) github.com/samber/mo.Task[R]
github.com/samber/mo.NewTaskFromIO ::
func[R any](io github.com/samber/mo.IO[R]) github.com/samber/mo.Task[R]
github.com/samber/mo.NewTask1 ::
func[R, A any](f github.com/samber/mo.ff1[R, A]) github.com/samber/mo.Task1[R, A]
github.com/samber/mo.NewTaskFromIO1 ::
func[R, A any](io github.com/samber/mo.IO1[R, A]) github.com/samber/mo.Task1[R, A]
github.com/samber/mo.NewTask2 ::
func[R, A, B any](f github.com/samber/mo.ff2[R, A, B]) github.com/samber/mo.Task2[R, A, B]
github.com/samber/mo.NewTaskFromIO2 ::
func[R, A, B any](io github.com/samber/mo.IO2[R, A, B]) github.com/samber/mo.Task2[R, A, B]
github.com/samber/mo.NewTask3 ::
func[R, A, B, C any](f github.com/samber/mo.ff3[R, A, B, C]) github.com/samber/mo.Task3[R, A, B, C]
github.com/samber/mo.NewTaskFromIO3 ::
func[R, A, B, C any](io github.com/samber/mo.IO3[R, A, B, C]) github.com/samber/mo.Task3[R, A, B, C]
github.com/samber/mo.NewTask4 ::
func[R, A, B, C, D any](f github.com/samber/mo.ff4[R, A, B, C, D]) github.com/samber/mo.Task4[R, A, B, C, D]
github.com/samber/mo.NewTaskFromIO4 ::
func[R, A, B, C, D any](io github.com/samber/mo.IO4[R, A, B, C, D]) github.com/samber/mo.Task4[R, A, B, C, D]
github.com/samber/mo.NewTask5 ::
func[R, A, B, C, D, E any](f github.com/samber/mo.ff5[R, A, B, C, D, E]) github.com/samber/mo.Task5[R, A, B, C, D, E]
github.com/samber/mo.NewTaskFromIO5 ::
func[R, A, B, C, D, E any](io github.com/samber/mo.IO5[R, A, B, C, D, E]) github.com/samber/mo.Task5[R, A, B, C, D, E]
github.com/samber/mo.NewTaskEither ::
func[R any](f github.com/samber/mo.ff0[R]) github.com/samber/mo.TaskEither[R]
github.com/samber/mo.NewTaskEitherFromIO ::
func[R any](io github.com/samber/mo.IO[R]) github.com/samber/mo.TaskEither[R]
github.com/thoas/go-funk.Set ::
func(in interface{}, val interface{}, path string) error
github.com/thoas/go-funk.MustSet ::
func(in interface{}, val interface{}, path string)
github.com/thoas/go-funk.Chain ::
func(v interface{}) github.com/thoas/go-funk.Builder
github.com/thoas/go-funk.LazyChain ::
func(v interface{}) github.com/thoas/go-funk.Builder
github.com/thoas/go-funk.LazyChainWith ::
func(generator func() interface{}) github.com/thoas/go-funk.Builder
github.com/thoas/go-funk.Compact ::
func(value interface{}) interface{}
github.com/thoas/go-funk.Fill ::
func(in interface{}, fillValue interface{}) (interface{}, error)
github.com/thoas/go-funk.ToFloat64 ::
func(x interface{}) (float64, bool)
github.com/thoas/go-funk.PtrOf ::
func(itf interface{}) interface{}
github.com/thoas/go-funk.IsFunction ::
func(in interface{}, num ...int) bool
github.com/thoas/go-funk.IsPredicate ::
func(in interface{}, inTypes ...reflect.Type) bool
github.com/thoas/go-funk.IsEqual ::
func(expected interface{}, actual interface{}) bool
github.com/thoas/go-funk.IsType ::
func(expected interface{}, actual interface{}) bool
github.com/thoas/go-funk.Equal ::
func(expected interface{}, actual interface{}) bool
github.com/thoas/go-funk.NotEqual ::
func(expected interface{}, actual interface{}) bool
github.com/thoas/go-funk.IsIteratee ::
func(in interface{}) bool
github.com/thoas/go-funk.IsCollection ::
func(in interface{}) bool
github.com/thoas/go-funk.SliceOf ::
func(in interface{}) interface{}
github.com/thoas/go-funk.Any ::
func(objs ...interface{}) bool
github.com/thoas/go-funk.All ::
func(objs ...interface{}) bool
github.com/thoas/go-funk.IsEmpty ::
func(obj interface{}) bool
github.com/thoas/go-funk.IsZero ::
func(obj interface{}) bool
github.com/thoas/go-funk.NotEmpty ::
func(obj interface{}) bool
github.com/thoas/go-funk.ZeroOf ::
func(in interface{}) interface{}
github.com/thoas/go-funk.RandomInt ::
func(min int, max int) int
github.com/thoas/go-funk.Shard ::
func(str string, width int, depth int, restOnly bool) []string
github.com/thoas/go-funk.RandomString ::
func(n int, allowedChars ...[]rune) string
github.com/thoas/go-funk.Intersect ::
func(x interface{}, y interface{}) interface{}
github.com/thoas/go-funk.IntersectString ::
func(x []string, y []string) []string
github.com/thoas/go-funk.Difference ::
func(x interface{}, y interface{}) (interface{}, interface{})
github.com/thoas/go-funk.DifferenceString ::
func(x []string, y []string) ([]string, []string)
github.com/thoas/go-funk.DifferenceInt64 ::
func(x []int64, y []int64) ([]int64, []int64)
github.com/thoas/go-funk.DifferenceInt32 ::
func(x []int32, y []int32) ([]int32, []int32)
github.com/thoas/go-funk.DifferenceInt ::
func(x []int, y []int) ([]int, []int)
github.com/thoas/go-funk.DifferenceUInt ::
func(x []uint, y []uint) ([]uint, []uint)
github.com/thoas/go-funk.DifferenceUInt32 ::
func(x []uint32, y []uint32) ([]uint32, []uint32)
github.com/thoas/go-funk.DifferenceUInt64 ::
func(x []uint64, y []uint64) ([]uint64, []uint64)
github.com/thoas/go-funk.Join ::
func(larr interface{}, rarr interface{}, fnc github.com/thoas/go-funk.JoinFnc) interface{}
github.com/thoas/go-funk.InnerJoin ::
func(lx reflect.Value, rx reflect.Value) reflect.Value
github.com/thoas/go-funk.OuterJoin ::
func(lx reflect.Value, rx reflect.Value) reflect.Value
github.com/thoas/go-funk.LeftJoin ::
func(lx reflect.Value, rx reflect.Value) reflect.Value
github.com/thoas/go-funk.RightJoin ::
func(lx reflect.Value, rx reflect.Value) reflect.Value
github.com/thoas/go-funk.StringerJoin ::
func(elems []interface{String() string}, sep string) string
github.com/thoas/go-funk.JoinInt ::
func(larr []int, rarr []int, fnc github.com/thoas/go-funk.JoinIntFnc) []int
github.com/thoas/go-funk.InnerJoinInt ::
func(lx []int, rx []int) []int
github.com/thoas/go-funk.OuterJoinInt ::
func(lx []int, rx []int) []int
github.com/thoas/go-funk.LeftJoinInt ::
func(lx []int, rx []int) []int
github.com/thoas/go-funk.RightJoinInt ::
func(lx []int, rx []int) []int
github.com/thoas/go-funk.JoinInt32 ::
func(larr []int32, rarr []int32, fnc github.com/thoas/go-funk.JoinInt32Fnc) []int32
github.com/thoas/go-funk.InnerJoinInt32 ::
func(lx []int32, rx []int32) []int32
github.com/thoas/go-funk.OuterJoinInt32 ::
func(lx []int32, rx []int32) []int32
github.com/thoas/go-funk.LeftJoinInt32 ::
func(lx []int32, rx []int32) []int32
github.com/thoas/go-funk.RightJoinInt32 ::
func(lx []int32, rx []int32) []int32
github.com/thoas/go-funk.JoinInt64 ::
func(larr []int64, rarr []int64, fnc github.com/thoas/go-funk.JoinInt64Fnc) []int64
github.com/thoas/go-funk.InnerJoinInt64 ::
func(lx []int64, rx []int64) []int64
github.com/thoas/go-funk.OuterJoinInt64 ::
func(lx []int64, rx []int64) []int64
github.com/thoas/go-funk.LeftJoinInt64 ::
func(lx []int64, rx []int64) []int64
github.com/thoas/go-funk.RightJoinInt64 ::
func(lx []int64, rx []int64) []int64
github.com/thoas/go-funk.JoinString ::
func(larr []string, rarr []string, fnc github.com/thoas/go-funk.JoinStringFnc) []string
github.com/thoas/go-funk.InnerJoinString ::
func(lx []string, rx []string) []string
github.com/thoas/go-funk.OuterJoinString ::
func(lx []string, rx []string) []string
github.com/thoas/go-funk.LeftJoinString ::
func(lx []string, rx []string) []string
github.com/thoas/go-funk.RightJoinString ::
func(lx []string, rx []string) []string
github.com/thoas/go-funk.JoinFloat32 ::
func(larr []float32, rarr []float32, fnc github.com/thoas/go-funk.JoinFloat32Fnc) []float32
github.com/thoas/go-funk.InnerJoinFloat32 ::
func(lx []float32, rx []float32) []float32
github.com/thoas/go-funk.OuterJoinFloat32 ::
func(lx []float32, rx []float32) []float32
github.com/thoas/go-funk.LeftJoinFloat32 ::
func(lx []float32, rx []float32) []float32
github.com/thoas/go-funk.RightJoinFloat32 ::
func(lx []float32, rx []float32) []float32
github.com/thoas/go-funk.JoinFloat64 ::
func(larr []float64, rarr []float64, fnc github.com/thoas/go-funk.JoinFloat64Fnc) []float64
github.com/thoas/go-funk.InnerJoinFloat64 ::
func(lx []float64, rx []float64) []float64
github.com/thoas/go-funk.OuterJoinFloat64 ::
func(lx []float64, rx []float64) []float64
github.com/thoas/go-funk.LeftJoinFloat64 ::
func(lx []float64, rx []float64) []float64
github.com/thoas/go-funk.RightJoinFloat64 ::
func(lx []float64, rx []float64) []float64
github.com/thoas/go-funk.Keys ::
func(out interface{}) interface{}
github.com/thoas/go-funk.Values ::
func(out interface{}) interface{}
github.com/thoas/go-funk.MaxInt ::
func(i []int) int
github.com/thoas/go-funk.MaxInt8 ::
func(i []int8) int8
github.com/thoas/go-funk.MaxInt16 ::
func(i []int16) int16
github.com/thoas/go-funk.MaxInt32 ::
func(i []int32) int32
github.com/thoas/go-funk.MaxInt64 ::
func(i []int64) int64
github.com/thoas/go-funk.MaxFloat32 ::
func(i []float32) float32
github.com/thoas/go-funk.MaxFloat64 ::
func(i []float64) float64
github.com/thoas/go-funk.MaxString ::
func(i []string) string
github.com/thoas/go-funk.MinInt ::
func(i []int) int
github.com/thoas/go-funk.MinInt8 ::
func(i []int8) int8
github.com/thoas/go-funk.MinInt16 ::
func(i []int16) int16
github.com/thoas/go-funk.MinInt32 ::
func(i []int32) int32
github.com/thoas/go-funk.MinInt64 ::
func(i []int64) int64
github.com/thoas/go-funk.MinFloat32 ::
func(i []float32) float32
github.com/thoas/go-funk.MinFloat64 ::
func(i []float64) float64
github.com/thoas/go-funk.MinString ::
func(i []string) string
github.com/thoas/go-funk.Sum ::
func(arr interface{}) float64
github.com/thoas/go-funk.Product ::
func(arr interface{}) float64
github.com/thoas/go-funk.WithAllowZero ::
func() func(*github.com/thoas/go-funk.options)
github.com/thoas/go-funk.NextPermutation ::
func(nums []int) error
github.com/thoas/go-funk.AnyPredicates ::
func(value interface{}, predicates interface{}) bool
github.com/thoas/go-funk.AllPredicates ::
func(value interface{}, predicates interface{}) bool
github.com/thoas/go-funk.Filter ::
func(arr interface{}, predicate interface{}) interface{}
github.com/thoas/go-funk.Find ::
func(arr interface{}, predicate interface{}) interface{}
github.com/thoas/go-funk.FindKey ::
func(arr interface{}, predicate interface{}) (matchKey interface{}, matchEle interface{})
github.com/thoas/go-funk.IndexOf ::
func(in interface{}, elem interface{}) int
github.com/thoas/go-funk.LastIndexOf ::
func(in interface{}, elem interface{}) int
github.com/thoas/go-funk.Contains ::
func(in interface{}, elem interface{}) bool
github.com/thoas/go-funk.Every ::
func(in interface{}, elements ...interface{}) bool
github.com/thoas/go-funk.Some ::
func(in interface{}, elements ...interface{}) bool
github.com/thoas/go-funk.Reduce ::
func(arr interface{}, reduceFunc interface{}, acc interface{}) interface{}
github.com/thoas/go-funk.Get ::
func(out interface{}, path string, opts ...github.com/thoas/go-funk.option) interface{}
github.com/thoas/go-funk.GetOrElse ::
func(v interface{}, def interface{}) interface{}
github.com/thoas/go-funk.ForEach ::
func(arr interface{}, predicate interface{})
github.com/thoas/go-funk.ForEachRight ::
func(arr interface{}, predicate interface{})
github.com/thoas/go-funk.Head ::
func(arr interface{}) interface{}
github.com/thoas/go-funk.Last ::
func(arr interface{}) interface{}
github.com/thoas/go-funk.Initial ::
func(arr interface{}) interface{}
github.com/thoas/go-funk.Tail ::
func(arr interface{}) interface{}
github.com/thoas/go-funk.ShortIf ::
func(condition bool, a interface{}, b interface{}) interface{}
github.com/thoas/go-funk.Subset ::
func(x interface{}, y interface{}) bool
github.com/thoas/go-funk.Subtract ::
func(x interface{}, y interface{}) interface{}
github.com/thoas/go-funk.SubtractString ::
func(x []string, y []string) []string
github.com/thoas/go-funk.Chunk ::
func(arr interface{}, size int) interface{}
github.com/thoas/go-funk.ToMap ::
func(in interface{}, pivot string) interface{}
github.com/thoas/go-funk.ToSet ::
func(in interface{}) interface{}
github.com/thoas/go-funk.Map ::
func(arr interface{}, mapFunc interface{}) interface{}
github.com/thoas/go-funk.FlatMap ::
func(arr interface{}, mapFunc interface{}) interface{}
github.com/thoas/go-funk.Flatten ::
func(out interface{}) interface{}
github.com/thoas/go-funk.FlattenDeep ::
func(out interface{}) interface{}
github.com/thoas/go-funk.Shuffle ::
func(in interface{}) interface{}
github.com/thoas/go-funk.Reverse ::
func(in interface{}) interface{}
github.com/thoas/go-funk.Uniq ::
func(in interface{}) interface{}
github.com/thoas/go-funk.UniqBy ::
func(in interface{}, mapFunc interface{}) interface{}
github.com/thoas/go-funk.ConvertSlice ::
func(in interface{}, out interface{})
github.com/thoas/go-funk.Drop ::
func(in interface{}, n int) interface{}
github.com/thoas/go-funk.Prune ::
func(in interface{}, paths []string) (interface{}, error)
github.com/thoas/go-funk.PruneByTag ::
func(in interface{}, paths []string, tag string) (interface{}, error)
github.com/thoas/go-funk.InBools ::
func(s []bool, v bool) bool
github.com/thoas/go-funk.InInts ::
func(s []int, v int) bool
github.com/thoas/go-funk.InInt32s ::
func(s []int32, v int32) bool
github.com/thoas/go-funk.InInt64s ::
func(s []int64, v int64) bool
github.com/thoas/go-funk.InUInts ::
func(s []uint, v uint) bool
github.com/thoas/go-funk.InUInt32s ::
func(s []uint32, v uint32) bool
github.com/thoas/go-funk.InUInt64s ::
func(s []uint64, v uint64) bool
github.com/thoas/go-funk.InStrings ::
func(s []string, v string) bool
github.com/thoas/go-funk.InFloat32s ::
func(s []float32, v float32) bool
github.com/thoas/go-funk.InFloat64s ::
func(s []float64, v float64) bool
github.com/thoas/go-funk.FindFloat64 ::
func(s []float64, cb func(s float64) bool) (float64, bool)
github.com/thoas/go-funk.FindFloat32 ::
func(s []float32, cb func(s float32) bool) (float32, bool)
github.com/thoas/go-funk.FindInt ::
func(s []int, cb func(s int) bool) (int, bool)
github.com/thoas/go-funk.FindInt32 ::
func(s []int32, cb func(s int32) bool) (int32, bool)
github.com/thoas/go-funk.FindInt64 ::
func(s []int64, cb func(s int64) bool) (int64, bool)
github.com/thoas/go-funk.FindString ::
func(s []string, cb func(s string) bool) (string, bool)
github.com/thoas/go-funk.FilterBool ::
func(s []bool, cb func(s bool) bool) []bool
github.com/thoas/go-funk.FilterFloat64 ::
func(s []float64, cb func(s float64) bool) []float64
github.com/thoas/go-funk.FilterFloat32 ::
func(s []float32, cb func(s float32) bool) []float32
github.com/thoas/go-funk.FilterInt ::
func(s []int, cb func(s int) bool) []int
github.com/thoas/go-funk.FilterInt32 ::
func(s []int32, cb func(s int32) bool) []int32
github.com/thoas/go-funk.FilterInt64 ::
func(s []int64, cb func(s int64) bool) []int64
github.com/thoas/go-funk.FilterUInt ::
func(s []uint, cb func(s uint) bool) []uint
github.com/thoas/go-funk.FilterUInt32 ::
func(s []uint32, cb func(s uint32) bool) []uint32
github.com/thoas/go-funk.FilterUInt64 ::
func(s []uint64, cb func(s uint64) bool) []uint64
github.com/thoas/go-funk.FilterString ::
func(s []string, cb func(s string) bool) []string
github.com/thoas/go-funk.ContainsBool ::
func(s []bool, v bool) bool
github.com/thoas/go-funk.ContainsInt ::
func(s []int, v int) bool
github.com/thoas/go-funk.ContainsInt32 ::
func(s []int32, v int32) bool
github.com/thoas/go-funk.ContainsInt64 ::
func(s []int64, v int64) bool
github.com/thoas/go-funk.ContainsUInt ::
func(s []uint, v uint) bool
github.com/thoas/go-funk.ContainsUInt32 ::
func(s []uint32, v uint32) bool
github.com/thoas/go-funk.ContainsUInt64 ::
func(s []uint64, v uint64) bool
github.com/thoas/go-funk.ContainsString ::
func(s []string, v string) bool
github.com/thoas/go-funk.ContainsFloat32 ::
func(s []float32, v float32) bool
github.com/thoas/go-funk.ContainsFloat64 ::
func(s []float64, v float64) bool
github.com/thoas/go-funk.SumInt32 ::
func(s []int32) (sum int32)
github.com/thoas/go-funk.SumInt64 ::
func(s []int64) (sum int64)
github.com/thoas/go-funk.SumInt ::
func(s []int) (sum int)
github.com/thoas/go-funk.SumUInt32 ::
func(s []uint32) (sum uint32)
github.com/thoas/go-funk.SumUInt64 ::
func(s []uint64) (sum uint64)
github.com/thoas/go-funk.SumUInt ::
func(s []uint) (sum uint)
github.com/thoas/go-funk.SumFloat64 ::
func(s []float64) (sum float64)
github.com/thoas/go-funk.SumFloat32 ::
func(s []float32) (sum float32)
github.com/thoas/go-funk.ReverseBools ::
func(s []bool) []bool
github.com/thoas/go-funk.ReverseStrings ::
func(s []string) []string
github.com/thoas/go-funk.ReverseInt ::
func(s []int) []int
github.com/thoas/go-funk.ReverseInt32 ::
func(s []int32) []int32
github.com/thoas/go-funk.ReverseInt64 ::
func(s []int64) []int64
github.com/thoas/go-funk.ReverseUInt ::
func(s []uint) []uint
github.com/thoas/go-funk.ReverseUInt32 ::
func(s []uint32) []uint32
github.com/thoas/go-funk.ReverseUInt64 ::
func(s []uint64) []uint64
github.com/thoas/go-funk.ReverseFloat64 ::
func(s []float64) []float64
github.com/thoas/go-funk.ReverseFloat32 ::
func(s []float32) []float32
github.com/thoas/go-funk.ReverseString ::
func(s string) string
github.com/thoas/go-funk.IndexOfBool ::
func(a []bool, x bool) int
github.com/thoas/go-funk.IndexOfInt ::
func(a []int, x int) int
github.com/thoas/go-funk.IndexOfInt32 ::
func(a []int32, x int32) int
github.com/thoas/go-funk.IndexOfInt64 ::
func(a []int64, x int64) int
github.com/thoas/go-funk.IndexOfUInt ::
func(a []uint, x uint) int
github.com/thoas/go-funk.IndexOfUInt32 ::
func(a []uint32, x uint32) int
github.com/thoas/go-funk.IndexOfUInt64 ::
func(a []uint64, x uint64) int
github.com/thoas/go-funk.IndexOfFloat64 ::
func(a []float64, x float64) int
github.com/thoas/go-funk.IndexOfString ::
func(a []string, x string) int
github.com/thoas/go-funk.LastIndexOfBool ::
func(a []bool, x bool) int
github.com/thoas/go-funk.LastIndexOfInt ::
func(a []int, x int) int
github.com/thoas/go-funk.LastIndexOfInt32 ::
func(a []int32, x int32) int
github.com/thoas/go-funk.LastIndexOfInt64 ::
func(a []int64, x int64) int
github.com/thoas/go-funk.LastIndexOfUInt ::
func(a []uint, x uint) int
github.com/thoas/go-funk.LastIndexOfUInt32 ::
func(a []uint32, x uint32) int
github.com/thoas/go-funk.LastIndexOfUInt64 ::
func(a []uint64, x uint64) int
github.com/thoas/go-funk.LastIndexOfFloat64 ::
func(a []float64, x float64) int
github.com/thoas/go-funk.LastIndexOfFloat32 ::
func(a []float32, x float32) int
github.com/thoas/go-funk.LastIndexOfString ::
func(a []string, x string) int
github.com/thoas/go-funk.UniqBool ::
func(a []bool) []bool
github.com/thoas/go-funk.UniqInt32 ::
func(a []int32) []int32
github.com/thoas/go-funk.UniqInt64 ::
func(a []int64) []int64
github.com/thoas/go-funk.UniqInt ::
func(a []int) []int
github.com/thoas/go-funk.UniqUInt32 ::
func(a []uint32) []uint32
github.com/thoas/go-funk.UniqUInt64 ::
func(a []uint64) []uint64
github.com/thoas/go-funk.UniqUInt ::
func(a []uint) []uint
github.com/thoas/go-funk.UniqString ::
func(a []string) []string
github.com/thoas/go-funk.UniqFloat64 ::
func(a []float64) []float64
github.com/thoas/go-funk.UniqFloat32 ::
func(a []float32) []float32
github.com/thoas/go-funk.ShuffleBool ::
func(a []bool) []bool
github.com/thoas/go-funk.ShuffleInt ::
func(a []int) []int
github.com/thoas/go-funk.ShuffleInt32 ::
func(a []int32) []int32
github.com/thoas/go-funk.ShuffleInt64 ::
func(a []int64) []int64
github.com/thoas/go-funk.ShuffleUInt ::
func(a []uint) []uint
github.com/thoas/go-funk.ShuffleUInt32 ::
func(a []uint32) []uint32
github.com/thoas/go-funk.ShuffleUInt64 ::
func(a []uint64) []uint64
github.com/thoas/go-funk.ShuffleString ::
func(a []string) []string
github.com/thoas/go-funk.ShuffleFloat32 ::
func(a []float32) []float32
github.com/thoas/go-funk.ShuffleFloat64 ::
func(a []float64) []float64
github.com/thoas/go-funk.DropBool ::
func(s []bool, n int) []bool
github.com/thoas/go-funk.DropString ::
func(s []string, n int) []string
github.com/thoas/go-funk.DropInt ::
func(s []int, n int) []int
github.com/thoas/go-funk.DropInt32 ::
func(s []int32, n int) []int32
github.com/thoas/go-funk.DropInt64 ::
func(s []int64, n int) []int64
github.com/thoas/go-funk.DropUInt ::
func(s []uint, n uint) []uint
github.com/thoas/go-funk.DropUInt32 ::
func(s []uint32, n int) []uint32
github.com/thoas/go-funk.DropUInt64 ::
func(s []uint64, n int) []uint64
github.com/thoas/go-funk.DropFloat32 ::
func(s []float32, n int) []float32
github.com/thoas/go-funk.DropFloat64 ::
func(s []float64, n int) []float64
github.com/thoas/go-funk.ChunkStrings ::
func(arr []string, size int) [][]string
github.com/thoas/go-funk.ChunkInts ::
func(arr []int, size int) [][]int
github.com/thoas/go-funk.ChunkInt32s ::
func(arr []int32, size int) [][]int32
github.com/thoas/go-funk.ChunkInt64s ::
func(arr []int64, size int) [][]int64
github.com/thoas/go-funk.ChunkUInts ::
func(arr []uint, size int) [][]uint
github.com/thoas/go-funk.ChunkUInt32s ::
func(arr []uint32, size int) [][]uint32
github.com/thoas/go-funk.ChunkUInt64s ::
func(arr []uint64, size int) [][]uint64
github.com/thoas/go-funk.ChunkFloat64s ::
func(arr []float64, size int) [][]float64
github.com/thoas/go-funk.Union ::
func(collections ...interface{}) interface{}
github.com/thoas/go-funk.UnionStringMap ::
func(x ...map[string]string) map[string]string
github.com/thoas/go-funk.Without ::
func(in interface{}, values ...interface{}) interface{}
github.com/thoas/go-funk.Zip ::
func(slice1 interface{}, slice2 interface{}) []github.com/thoas/go-funk.Tuple
github.com/dominikbraun/graph.TopologicalSort ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T]) ([]K, error)
github.com/dominikbraun/graph.StableTopologicalSort ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], less func(K, K) bool) ([]K, error)
github.com/dominikbraun/graph.TransitiveReduction ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T]) (github.com/dominikbraun/graph.Graph[K, T], error)
github.com/dominikbraun/graph.New ::
func[K comparable, T any](hash github.com/dominikbraun/graph.Hash[K, T], options ...func(*github.com/dominikbraun/graph.Traits)) github.com/dominikbraun/graph.Graph[K, T]
github.com/dominikbraun/graph.NewWithStore ::
func[K comparable, T any](hash github.com/dominikbraun/graph.Hash[K, T], store github.com/dominikbraun/graph.Store[K, T], options ...func(*github.com/dominikbraun/graph.Traits)) github.com/dominikbraun/graph.Graph[K, T]
github.com/dominikbraun/graph.NewLike ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T]) github.com/dominikbraun/graph.Graph[K, T]
github.com/dominikbraun/graph.StringHash ::
func(v string) string
github.com/dominikbraun/graph.IntHash ::
func(v int) int
github.com/dominikbraun/graph.EdgeWeight ::
func(weight int) func(*github.com/dominikbraun/graph.EdgeProperties)
github.com/dominikbraun/graph.EdgeAttribute ::
func(key string, value string) func(*github.com/dominikbraun/graph.EdgeProperties)
github.com/dominikbraun/graph.EdgeAttributes ::
func(attributes map[string]string) func(*github.com/dominikbraun/graph.EdgeProperties)
github.com/dominikbraun/graph.EdgeData ::
func(data any) func(*github.com/dominikbraun/graph.EdgeProperties)
github.com/dominikbraun/graph.VertexWeight ::
func(weight int) func(*github.com/dominikbraun/graph.VertexProperties)
github.com/dominikbraun/graph.VertexAttribute ::
func(key string, value string) func(*github.com/dominikbraun/graph.VertexProperties)
github.com/dominikbraun/graph.VertexAttributes ::
func(attributes map[string]string) func(*github.com/dominikbraun/graph.VertexProperties)
github.com/dominikbraun/graph.CreatesCycle ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], source K, target K) (bool, error)
github.com/dominikbraun/graph.ShortestPath ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], source K, target K) ([]K, error)
github.com/dominikbraun/graph.StronglyConnectedComponents ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T]) ([][]K, error)
github.com/dominikbraun/graph.AllPathsBetween ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], start K, end K) ([][]K, error)
github.com/dominikbraun/graph.Union ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], h github.com/dominikbraun/graph.Graph[K, T]) (github.com/dominikbraun/graph.Graph[K, T], error)
github.com/dominikbraun/graph.Directed ::
func() func(*github.com/dominikbraun/graph.Traits)
github.com/dominikbraun/graph.Acyclic ::
func() func(*github.com/dominikbraun/graph.Traits)
github.com/dominikbraun/graph.Weighted ::
func() func(*github.com/dominikbraun/graph.Traits)
github.com/dominikbraun/graph.Rooted ::
func() func(*github.com/dominikbraun/graph.Traits)
github.com/dominikbraun/graph.Tree ::
func() func(*github.com/dominikbraun/graph.Traits)
github.com/dominikbraun/graph.PreventCycles ::
func() func(*github.com/dominikbraun/graph.Traits)
github.com/dominikbraun/graph.DFS ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], start K, visit func(K) bool) error
github.com/dominikbraun/graph.BFS ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], start K, visit func(K) bool) error
github.com/dominikbraun/graph.BFSWithDepth ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T], start K, visit func(K, int) bool) error
github.com/dominikbraun/graph.MinimumSpanningTree ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T]) (github.com/dominikbraun/graph.Graph[K, T], error)
github.com/dominikbraun/graph.MaximumSpanningTree ::
func[K comparable, T any](g github.com/dominikbraun/graph.Graph[K, T]) (github.com/dominikbraun/graph.Graph[K, T], error)
github.com/jinzhu/now.With ::
func(t time.Time) *github.com/jinzhu/now.Now
github.com/jinzhu/now.New ::
func(t time.Time) *github.com/jinzhu/now.Now
github.com/jinzhu/now.BeginningOfMinute ::
func() time.Time
github.com/jinzhu/now.BeginningOfHour ::
func() time.Time
github.com/jinzhu/now.BeginningOfDay ::
func() time.Time
github.com/jinzhu/now.BeginningOfWeek ::
func() time.Time
github.com/jinzhu/now.BeginningOfMonth ::
func() time.Time
github.com/jinzhu/now.BeginningOfQuarter ::
func() time.Time
github.com/jinzhu/now.BeginningOfYear ::
func() time.Time
github.com/jinzhu/now.EndOfMinute ::
func() time.Time
github.com/jinzhu/now.EndOfHour ::
func() time.Time
github.com/jinzhu/now.EndOfDay ::
func() time.Time
github.com/jinzhu/now.EndOfWeek ::
func() time.Time
github.com/jinzhu/now.EndOfMonth ::
func() time.Time
github.com/jinzhu/now.EndOfQuarter ::
func() time.Time
github.com/jinzhu/now.EndOfYear ::
func() time.Time
github.com/jinzhu/now.Monday ::
func(strs ...string) time.Time
github.com/jinzhu/now.Sunday ::
func(strs ...string) time.Time
github.com/jinzhu/now.EndOfSunday ::
func() time.Time
github.com/jinzhu/now.Quarter ::
func() uint
github.com/jinzhu/now.Parse ::
func(strs ...string) (time.Time, error)
github.com/jinzhu/now.ParseInLocation ::
func(loc *time.Location, strs ...string) (time.Time, error)
github.com/jinzhu/now.MustParse ::
func(strs ...string) time.Time
github.com/jinzhu/now.MustParseInLocation ::
func(loc *time.Location, strs ...string) time.Time
github.com/jinzhu/now.Between ::
func(time1 string, time2 string) bool
github.com/sourcegraph/conc.NewWaitGroup ::
func() *github.com/sourcegraph/conc.WaitGroup
github.com/go-resty/resty/v2.NoRedirectPolicy ::
func() github.com/go-resty/resty/v2.RedirectPolicy
github.com/go-resty/resty/v2.FlexibleRedirectPolicy ::
func(noOfRedirect int) github.com/go-resty/resty/v2.RedirectPolicy
github.com/go-resty/resty/v2.DomainCheckRedirectPolicy ::
func(hostnames ...string) github.com/go-resty/resty/v2.RedirectPolicy
github.com/go-resty/resty/v2.New ::
func() *github.com/go-resty/resty/v2.Client
github.com/go-resty/resty/v2.NewWithClient ::
func(hc *net/http.Client) *github.com/go-resty/resty/v2.Client
github.com/go-resty/resty/v2.NewWithLocalAddr ::
func(localAddr net.Addr) *github.com/go-resty/resty/v2.Client
github.com/go-resty/resty/v2.Retries ::
func(value int) github.com/go-resty/resty/v2.Option
github.com/go-resty/resty/v2.WaitTime ::
func(value time.Duration) github.com/go-resty/resty/v2.Option
github.com/go-resty/resty/v2.MaxWaitTime ::
func(value time.Duration) github.com/go-resty/resty/v2.Option
github.com/go-resty/resty/v2.RetryConditions ::
func(conditions []github.com/go-resty/resty/v2.RetryConditionFunc) github.com/go-resty/resty/v2.Option
github.com/go-resty/resty/v2.RetryHooks ::
func(hooks []github.com/go-resty/resty/v2.OnRetryFunc) github.com/go-resty/resty/v2.Option
github.com/go-resty/resty/v2.ResetMultipartReaders ::
func(value bool) github.com/go-resty/resty/v2.Option
github.com/go-resty/resty/v2.Backoff ::
func(operation func() (*github.com/go-resty/resty/v2.Response, error), options ...github.com/go-resty/resty/v2.Option) error
github.com/go-resty/resty/v2.IsStringEmpty ::
func(str string) bool
github.com/go-resty/resty/v2.DetectContentType ::
func(body interface{}) string
github.com/go-resty/resty/v2.IsJSONType ::
func(ct string) bool
github.com/go-resty/resty/v2.IsXMLType ::
func(ct string) bool
github.com/go-resty/resty/v2.Unmarshalc ::
func(c *github.com/go-resty/resty/v2.Client, ct string, b []byte, d interface{}) (err error)
gorm.io/gorm.Open ::
func(dialector gorm.io/gorm.Dialector, opts ...gorm.io/gorm.Option) (db *gorm.io/gorm.DB, err error)
gorm.io/gorm.Expr ::
func(expr string, args ...interface{}) gorm.io/gorm/clause.Expr
gorm.io/gorm.NewPreparedStmtDB ::
func(connPool gorm.io/gorm.ConnPool) *gorm.io/gorm.PreparedStmtDB
gorm.io/gorm.Scan ::
func(rows gorm.io/gorm.Rows, db *gorm.io/gorm.DB, mode gorm.io/gorm.ScanMode)
xorm.io/xorm.NewEngine ::
func(driverName string, dataSourceName string, driverOptions ...func(db *database/sql.DB) error) (*xorm.io/xorm.Engine, error)
xorm.io/xorm.NewEngineWithParams ::
func(driverName string, dataSourceName string, params map[string]string) (*xorm.io/xorm.Engine, error)
xorm.io/xorm.NewEngineWithDB ::
func(driverName string, dataSourceName string, db *xorm.io/xorm/core.DB) (*xorm.io/xorm.Engine, error)
xorm.io/xorm.NewEngineWithDialectAndDB ::
func(driverName string, dataSourceName string, dialect xorm.io/xorm/dialects.Dialect, db *xorm.io/xorm/core.DB) (*xorm.io/xorm.Engine, error)
xorm.io/xorm.NewEngineGroup ::
func(args1 interface{}, args2 interface{}, policies ...xorm.io/xorm.GroupPolicy) (*xorm.io/xorm.EngineGroup, error)
xorm.io/xorm.RandomPolicy ::
func() xorm.io/xorm.GroupPolicyHandler
xorm.io/xorm.WeightRandomPolicy ::
func(weights []int) xorm.io/xorm.GroupPolicyHandler
xorm.io/xorm.RoundRobinPolicy ::
func() xorm.io/xorm.GroupPolicyHandler
xorm.io/xorm.WeightRoundRobinPolicy ::
func(weights []int) xorm.io/xorm.GroupPolicyHandler
xorm.io/xorm.LeastConnPolicy ::
func() xorm.io/xorm.GroupPolicyHandler
xorm.io/xorm.SetDefaultJSONHandler ::
func(jsonHandler xorm.io/xorm/internal/json.Interface)
xorm.io/xorm.ParseColumnsSchema ::
func(fieldNames []string, types []*database/sql.ColumnType, table *xorm.io/xorm/schemas.Table) *xorm.io/xorm.ColumnsSchema
github.com/stretchr/testify/assert.Greater ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.GreaterOrEqual ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Less ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.LessOrEqual ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Positive ::
func(t github.com/stretchr/testify/assert.TestingT, e interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Negative ::
func(t github.com/stretchr/testify/assert.TestingT, e interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Conditionf ::
func(t github.com/stretchr/testify/assert.TestingT, comp github.com/stretchr/testify/assert.Comparison, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Containsf ::
func(t github.com/stretchr/testify/assert.TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.DirExistsf ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.ElementsMatchf ::
func(t github.com/stretchr/testify/assert.TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Emptyf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Equalf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.EqualErrorf ::
func(t github.com/stretchr/testify/assert.TestingT, theError error, errString string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.EqualExportedValuesf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.EqualValuesf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Errorf ::
func(t github.com/stretchr/testify/assert.TestingT, err error, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.ErrorAsf ::
func(t github.com/stretchr/testify/assert.TestingT, err error, target interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.ErrorContainsf ::
func(t github.com/stretchr/testify/assert.TestingT, theError error, contains string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.ErrorIsf ::
func(t github.com/stretchr/testify/assert.TestingT, err error, target error, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Eventuallyf ::
func(t github.com/stretchr/testify/assert.TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.EventuallyWithTf ::
func(t github.com/stretchr/testify/assert.TestingT, condition func(collect *github.com/stretchr/testify/assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Exactlyf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Failf ::
func(t github.com/stretchr/testify/assert.TestingT, failureMessage string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.FailNowf ::
func(t github.com/stretchr/testify/assert.TestingT, failureMessage string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Falsef ::
func(t github.com/stretchr/testify/assert.TestingT, value bool, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.FileExistsf ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Greaterf ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.GreaterOrEqualf ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.HTTPBodyContainsf ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, str interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.HTTPBodyNotContainsf ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, str interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.HTTPErrorf ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.HTTPRedirectf ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.HTTPStatusCodef ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, statuscode int, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.HTTPSuccessf ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Implementsf ::
func(t github.com/stretchr/testify/assert.TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.InDeltaf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.InDeltaMapValuesf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.InDeltaSlicef ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.InEpsilonf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.InEpsilonSlicef ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.IsDecreasingf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.IsIncreasingf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.IsNonDecreasingf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.IsNonIncreasingf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.IsTypef ::
func(t github.com/stretchr/testify/assert.TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.JSONEqf ::
func(t github.com/stretchr/testify/assert.TestingT, expected string, actual string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Lenf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, length int, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Lessf ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.LessOrEqualf ::
func(t github.com/stretchr/testify/assert.TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Negativef ::
func(t github.com/stretchr/testify/assert.TestingT, e interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Neverf ::
func(t github.com/stretchr/testify/assert.TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Nilf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NoDirExistsf ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NoErrorf ::
func(t github.com/stretchr/testify/assert.TestingT, err error, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NoFileExistsf ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotContainsf ::
func(t github.com/stretchr/testify/assert.TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotEmptyf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotEqualf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotEqualValuesf ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotErrorIsf ::
func(t github.com/stretchr/testify/assert.TestingT, err error, target error, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotImplementsf ::
func(t github.com/stretchr/testify/assert.TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotNilf ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotPanicsf ::
func(t github.com/stretchr/testify/assert.TestingT, f github.com/stretchr/testify/assert.PanicTestFunc, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotRegexpf ::
func(t github.com/stretchr/testify/assert.TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotSamef ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotSubsetf ::
func(t github.com/stretchr/testify/assert.TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.NotZerof ::
func(t github.com/stretchr/testify/assert.TestingT, i interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Panicsf ::
func(t github.com/stretchr/testify/assert.TestingT, f github.com/stretchr/testify/assert.PanicTestFunc, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.PanicsWithErrorf ::
func(t github.com/stretchr/testify/assert.TestingT, errString string, f github.com/stretchr/testify/assert.PanicTestFunc, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.PanicsWithValuef ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, f github.com/stretchr/testify/assert.PanicTestFunc, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Positivef ::
func(t github.com/stretchr/testify/assert.TestingT, e interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Regexpf ::
func(t github.com/stretchr/testify/assert.TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Samef ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Subsetf ::
func(t github.com/stretchr/testify/assert.TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Truef ::
func(t github.com/stretchr/testify/assert.TestingT, value bool, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.WithinDurationf ::
func(t github.com/stretchr/testify/assert.TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.WithinRangef ::
func(t github.com/stretchr/testify/assert.TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.YAMLEqf ::
func(t github.com/stretchr/testify/assert.TestingT, expected string, actual string, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.Zerof ::
func(t github.com/stretchr/testify/assert.TestingT, i interface{}, msg string, args ...interface{}) bool
github.com/stretchr/testify/assert.IsIncreasing ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.IsNonIncreasing ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.IsDecreasing ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.IsNonDecreasing ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.ObjectsAreEqual ::
func(expected interface{}, actual interface{}) bool
github.com/stretchr/testify/assert.ObjectsExportedFieldsAreEqual ::
func(expected interface{}, actual interface{}) bool
github.com/stretchr/testify/assert.ObjectsAreEqualValues ::
func(expected interface{}, actual interface{}) bool
github.com/stretchr/testify/assert.CallerInfo ::
func() []string
github.com/stretchr/testify/assert.FailNow ::
func(t github.com/stretchr/testify/assert.TestingT, failureMessage string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Fail ::
func(t github.com/stretchr/testify/assert.TestingT, failureMessage string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Implements ::
func(t github.com/stretchr/testify/assert.TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotImplements ::
func(t github.com/stretchr/testify/assert.TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.IsType ::
func(t github.com/stretchr/testify/assert.TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Equal ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Same ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotSame ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.EqualValues ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.EqualExportedValues ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Exactly ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotNil ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Nil ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Empty ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotEmpty ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Len ::
func(t github.com/stretchr/testify/assert.TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.True ::
func(t github.com/stretchr/testify/assert.TestingT, value bool, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.False ::
func(t github.com/stretchr/testify/assert.TestingT, value bool, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotEqual ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotEqualValues ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Contains ::
func(t github.com/stretchr/testify/assert.TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotContains ::
func(t github.com/stretchr/testify/assert.TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Subset ::
func(t github.com/stretchr/testify/assert.TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) (ok bool)
github.com/stretchr/testify/assert.NotSubset ::
func(t github.com/stretchr/testify/assert.TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) (ok bool)
github.com/stretchr/testify/assert.ElementsMatch ::
func(t github.com/stretchr/testify/assert.TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) (ok bool)
github.com/stretchr/testify/assert.Condition ::
func(t github.com/stretchr/testify/assert.TestingT, comp github.com/stretchr/testify/assert.Comparison, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Panics ::
func(t github.com/stretchr/testify/assert.TestingT, f github.com/stretchr/testify/assert.PanicTestFunc, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.PanicsWithValue ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, f github.com/stretchr/testify/assert.PanicTestFunc, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.PanicsWithError ::
func(t github.com/stretchr/testify/assert.TestingT, errString string, f github.com/stretchr/testify/assert.PanicTestFunc, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotPanics ::
func(t github.com/stretchr/testify/assert.TestingT, f github.com/stretchr/testify/assert.PanicTestFunc, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.WithinDuration ::
func(t github.com/stretchr/testify/assert.TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.WithinRange ::
func(t github.com/stretchr/testify/assert.TestingT, actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.InDelta ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.InDeltaSlice ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.InDeltaMapValues ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.InEpsilon ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.InEpsilonSlice ::
func(t github.com/stretchr/testify/assert.TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NoError ::
func(t github.com/stretchr/testify/assert.TestingT, err error, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Error ::
func(t github.com/stretchr/testify/assert.TestingT, err error, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.EqualError ::
func(t github.com/stretchr/testify/assert.TestingT, theError error, errString string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.ErrorContains ::
func(t github.com/stretchr/testify/assert.TestingT, theError error, contains string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Regexp ::
func(t github.com/stretchr/testify/assert.TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotRegexp ::
func(t github.com/stretchr/testify/assert.TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Zero ::
func(t github.com/stretchr/testify/assert.TestingT, i interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotZero ::
func(t github.com/stretchr/testify/assert.TestingT, i interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.FileExists ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NoFileExists ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.DirExists ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NoDirExists ::
func(t github.com/stretchr/testify/assert.TestingT, path string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.JSONEq ::
func(t github.com/stretchr/testify/assert.TestingT, expected string, actual string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.YAMLEq ::
func(t github.com/stretchr/testify/assert.TestingT, expected string, actual string, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Eventually ::
func(t github.com/stretchr/testify/assert.TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.EventuallyWithT ::
func(t github.com/stretchr/testify/assert.TestingT, condition func(collect *github.com/stretchr/testify/assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.Never ::
func(t github.com/stretchr/testify/assert.TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.ErrorIs ::
func(t github.com/stretchr/testify/assert.TestingT, err error, target error, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.NotErrorIs ::
func(t github.com/stretchr/testify/assert.TestingT, err error, target error, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.ErrorAs ::
func(t github.com/stretchr/testify/assert.TestingT, err error, target interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.New ::
func(t github.com/stretchr/testify/assert.TestingT) *github.com/stretchr/testify/assert.Assertions
github.com/stretchr/testify/assert.HTTPSuccess ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.HTTPRedirect ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.HTTPError ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.HTTPStatusCode ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, statuscode int, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.HTTPBody ::
func(handler net/http.HandlerFunc, method string, url string, values net/url.Values) string
github.com/stretchr/testify/assert.HTTPBodyContains ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, str interface{}, msgAndArgs ...interface{}) bool
github.com/stretchr/testify/assert.HTTPBodyNotContains ::
func(t github.com/stretchr/testify/assert.TestingT, handler net/http.HandlerFunc, method string, url string, values net/url.Values, str interface{}, msgAndArgs ...interface{}) bool