SYMBOL INDEX (599 symbols across 47 files)

FILE: binary_search.go
  function LowerBound (line 8) | func LowerBound[T Ordered](a []T, value T) int {
  function LowerBoundFunc (line 32) | func LowerBoundFunc[T any](a []T, value T, less LessFn[T]) int {
  function UpperBound (line 54) | func UpperBound[T Ordered](a []T, value T) int {
  function UpperBoundFunc (line 78) | func UpperBoundFunc[T any](a []T, value T, less LessFn[T]) int {
  function BinarySearch (line 100) | func BinarySearch[T Ordered](a []T, value T) (index int, ok bool) {
  function BinarySearchFunc (line 115) | func BinarySearchFunc[T any](a []T, value T, less LessFn[T]) (index int,...

FILE: binary_search_test.go
  function TestLowerBound (line 5) | func TestLowerBound(t *testing.T) {
  function TestLowerBoundFunc (line 12) | func TestLowerBoundFunc(t *testing.T) {
  function TestUpperBound (line 19) | func TestUpperBound(t *testing.T) {
  function TestUpperBoundFunc (line 26) | func TestUpperBoundFunc(t *testing.T) {
  function TestBinarySearch (line 33) | func TestBinarySearch(t *testing.T) {
  function TestBinarySearchFunc (line 48) | func TestBinarySearchFunc(t *testing.T) {

FILE: builtin_set.go
  type BuiltinSet (line 8) | type BuiltinSet
  function SetOf (line 11) | func SetOf[K comparable](ks ...K) BuiltinSet[K] {
  method IsEmpty (line 18) | func (s BuiltinSet[K]) IsEmpty() bool {
  method Len (line 23) | func (s BuiltinSet[K]) Len() int {
  method Clear (line 28) | func (s BuiltinSet[K]) Clear() {
  method Has (line 35) | func (s BuiltinSet[K]) Has(k K) bool {
  method Insert (line 41) | func (s BuiltinSet[K]) Insert(k K) bool {
  method InsertN (line 48) | func (s BuiltinSet[K]) InsertN(ks ...K) int {
  method Remove (line 57) | func (s BuiltinSet[K]) Remove(k K) bool {
  method Delete (line 65) | func (s BuiltinSet[K]) Delete(k K) {
  method RemoveN (line 70) | func (s BuiltinSet[K]) RemoveN(ks ...K) int {
  method Keys (line 79) | func (s BuiltinSet[K]) Keys() []K {
  method ForEach (line 88) | func (s BuiltinSet[K]) ForEach(cb func(k K)) {
  method ForEachIf (line 95) | func (s BuiltinSet[K]) ForEachIf(cb func(k K) bool) {
  method String (line 104) | func (s BuiltinSet[K]) String() string {
  method Update (line 109) | func (s BuiltinSet[K]) Update(other BuiltinSet[K]) {
  method Union (line 116) | func (s BuiltinSet[K]) Union(other BuiltinSet[K]) BuiltinSet[K] {
  function orderSet (line 123) | func orderSet[K comparable](a, b BuiltinSet[K]) (small, large BuiltinSet...
  method Intersection (line 131) | func (s BuiltinSet[K]) Intersection(other BuiltinSet[K]) BuiltinSet[K] {
  method Difference (line 143) | func (s BuiltinSet[K]) Difference(other BuiltinSet[K]) BuiltinSet[K] {
  method IsDisjointOf (line 155) | func (s BuiltinSet[K]) IsDisjointOf(other BuiltinSet[K]) bool {
  method IsSubsetOf (line 166) | func (s BuiltinSet[K]) IsSubsetOf(other BuiltinSet[K]) bool {
  method IsSupersetOf (line 179) | func (s BuiltinSet[K]) IsSupersetOf(other BuiltinSet[K]) bool {

FILE: builtin_set_test.go
  function Test_BuiltinSet_Interface (line 9) | func Test_BuiltinSet_Interface(t *testing.T) {
  function Test_MakeBuiltinSet (line 14) | func Test_MakeBuiltinSet(t *testing.T) {
  function Test_MakeBuiltinSet2 (line 20) | func Test_MakeBuiltinSet2(t *testing.T) {
  function Test_SetOf (line 26) | func Test_SetOf(t *testing.T) {
  function Test_BuiltinSet_IsEmpty (line 31) | func Test_BuiltinSet_IsEmpty(t *testing.T) {
  function Test_BuiltinSet_Clear (line 38) | func Test_BuiltinSet_Clear(t *testing.T) {
  function Test_BuiltinSet_String (line 44) | func Test_BuiltinSet_String(t *testing.T) {
  function Test_BuiltinSet_Has (line 49) | func Test_BuiltinSet_Has(t *testing.T) {
  function Test_BuiltinSet_Insert (line 56) | func Test_BuiltinSet_Insert(t *testing.T) {
  function Test_BuiltinSet_InsertN (line 66) | func Test_BuiltinSet_InsertN(t *testing.T) {
  function Test_BuiltinSet_Remove (line 72) | func Test_BuiltinSet_Remove(t *testing.T) {
  function Test_BuiltinSet_Delete (line 82) | func Test_BuiltinSet_Delete(t *testing.T) {
  function Test_BuiltinSet_RemoveN (line 92) | func Test_BuiltinSet_RemoveN(t *testing.T) {
  function Test_BuiltinSet_Keys (line 99) | func Test_BuiltinSet_Keys(t *testing.T) {
  function Test_BuiltinSet_For (line 105) | func Test_BuiltinSet_For(t *testing.T) {
  function Test_BuiltinSet_ForEach (line 112) | func Test_BuiltinSet_ForEach(t *testing.T) {
  function Test_BuiltinSet_ForEachIf (line 121) | func Test_BuiltinSet_ForEachIf(t *testing.T) {
  function Test_BuiltinSet_Update (line 131) | func Test_BuiltinSet_Update(t *testing.T) {
  function Test_BuiltinSet_Union (line 138) | func Test_BuiltinSet_Union(t *testing.T) {
  function Test_BuiltinSet_Intersection (line 145) | func Test_BuiltinSet_Intersection(t *testing.T) {
  function Test_BuiltinSet_Difference (line 154) | func Test_BuiltinSet_Difference(t *testing.T) {
  function Test_BuiltinSet_IsDisjointOf (line 165) | func Test_BuiltinSet_IsDisjointOf(t *testing.T) {
  function Test_BuiltinSet_IsSubsetOf (line 172) | func Test_BuiltinSet_IsSubsetOf(t *testing.T) {
  function Test_BuiltinSet_IsSupersetOf (line 181) | func Test_BuiltinSet_IsSupersetOf(t *testing.T) {

FILE: compare.go
  function Equal (line 7) | func Equal[T comparable](a, b []T) bool {
  function Compare (line 26) | func Compare[E Ordered](a, b []E) int {

FILE: compare_test.go
  function Test_Equal (line 5) | func Test_Equal(t *testing.T) {
  function Test_Compare (line 12) | func Test_Compare(t *testing.T) {

FILE: compute.go
  function SumAs (line 6) | func SumAs[R, T Numeric](a []T) R {
  function Sum (line 32) | func Sum[T Numeric](a []T) T {
  function AverageAs (line 37) | func AverageAs[R, T Numeric](a []T) R {
  function Average (line 42) | func Average[T Numeric](a []T) T {
  function Count (line 59) | func Count[T comparable](a []T, x T) int {
  function CountIf (line 72) | func CountIf[T comparable](a []T, pred func(T) bool) int {

FILE: compute_test.go
  function Test_SumAs (line 7) | func Test_SumAs(t *testing.T) {
  function Test_Sum (line 29) | func Test_Sum(t *testing.T) {
  function Test_Average (line 34) | func Test_Average(t *testing.T) {
  function Test_AverageAs (line 39) | func Test_AverageAs(t *testing.T) {
  function Test_Average_U64 (line 44) | func Test_Average_U64(t *testing.T) {
  function Test_Average_Float (line 49) | func Test_Average_Float(t *testing.T) {
  function Test_Average_SmallType (line 54) | func Test_Average_SmallType(t *testing.T) {
  function Test_Average_UintPtr (line 59) | func Test_Average_UintPtr(t *testing.T) {
  function Test_Average_Signed (line 64) | func Test_Average_Signed(t *testing.T) {
  function Test_Count (line 69) | func Test_Count(t *testing.T) {

FILE: container.go
  type Container (line 4) | type Container interface
  type Map (line 11) | type Map interface
  type Set (line 24) | type Set interface
  type SortedMap (line 36) | type SortedMap interface
  type SortedSet (line 53) | type SortedSet interface
  type Queue (line 71) | type Queue interface
  type Deque (line 81) | type Deque interface

FILE: dlist.go
  type DList (line 6) | type DList struct
  type dListNode (line 11) | type dListNode struct
  function DListOf (line 17) | func DListOf[T any](vs ...T) DList[T] {
  method Clear (line 26) | func (l *DList[T]) Clear() {
  method Len (line 35) | func (l *DList[T]) Len() int {
  method IsEmpty (line 40) | func (l *DList[T]) IsEmpty() bool {
  method String (line 45) | func (l *DList[T]) String() string {
  type dlistIterator (line 49) | type dlistIterator struct
  method IsNotEnd (line 54) | func (it *dlistIterator[T]) IsNotEnd() bool {
  method MoveToNext (line 58) | func (it *dlistIterator[T]) MoveToNext() {
  method Value (line 62) | func (it *dlistIterator[T]) Value() T {
  method Pointer (line 66) | func (it *dlistIterator[T]) Pointer() *T {
  method Iterate (line 71) | func (l *DList[T]) Iterate() MutableIterator[T] {
  method Front (line 80) | func (l *DList[T]) Front() T {
  method Back (line 88) | func (l *DList[T]) Back() T {
  method PushFront (line 96) | func (l *DList[T]) PushFront(val T) {
  method PushBack (line 105) | func (l *DList[T]) PushBack(val T) {
  method PopFront (line 114) | func (l *DList[T]) PopFront() T {
  method PopBack (line 123) | func (l *DList[T]) PopBack() T {
  method TryPopFront (line 132) | func (l *DList[T]) TryPopFront() (T, bool) {
  method TryPopBack (line 148) | func (l *DList[T]) TryPopBack() (T, bool) {
  method ForEach (line 164) | func (l *DList[T]) ForEach(cb func(val T)) {
  method ForEachIf (line 175) | func (l *DList[T]) ForEachIf(cb func(val T) bool) {
  method ForEachMutable (line 187) | func (l *DList[T]) ForEachMutable(cb func(val *T)) {
  method ForEachMutableIf (line 198) | func (l *DList[T]) ForEachMutableIf(cb func(val *T) bool) {
  method ensureHead (line 210) | func (l *DList[T]) ensureHead() {

FILE: dlist_queue.go
  type DListQueue (line 8) | type DListQueue struct
  function NewDListQueue (line 13) | func NewDListQueue[T any]() *DListQueue[T] {
  method Len (line 19) | func (q *DListQueue[T]) Len() int {
  method IsEmpty (line 24) | func (q *DListQueue[T]) IsEmpty() bool {
  method Clear (line 29) | func (q *DListQueue[T]) Clear() {
  method String (line 34) | func (q *DListQueue[T]) String() string {
  method Front (line 39) | func (q *DListQueue[T]) Front() T {
  method Back (line 44) | func (q *DListQueue[T]) Back() T {
  method PushFront (line 49) | func (q *DListQueue[T]) PushFront(val T) {
  method PushBack (line 54) | func (q *DListQueue[T]) PushBack(val T) {
  method PopFront (line 59) | func (q *DListQueue[T]) PopFront() T {
  method PopBack (line 64) | func (q *DListQueue[T]) PopBack() T {
  method TryPopFront (line 69) | func (q *DListQueue[T]) TryPopFront() (T, bool) {
  method TryPopBack (line 74) | func (q *DListQueue[T]) TryPopBack() (T, bool) {

FILE: dlist_queue_test.go
  function Test_Queue_Interface (line 7) | func Test_Queue_Interface(t *testing.T) {
  function Test_Queue_New (line 12) | func Test_Queue_New(t *testing.T) {
  function Test_Queue_Clear (line 18) | func Test_Queue_Clear(t *testing.T) {
  function Test_Queue_String (line 26) | func Test_Queue_String(t *testing.T) {
  function Test_Queue_Front_Back (line 31) | func Test_Queue_Front_Back(t *testing.T) {
  function Test_Queue_PushFront (line 41) | func Test_Queue_PushFront(t *testing.T) {
  function Test_Queue_PushBack (line 48) | func Test_Queue_PushBack(t *testing.T) {
  function Test_Queue_TryPopFront (line 55) | func Test_Queue_TryPopFront(t *testing.T) {
  function Test_Queue_TryPopBack (line 60) | func Test_Queue_TryPopBack(t *testing.T) {
  function Test_Queue_PushFront_PopFront (line 66) | func Test_Queue_PushFront_PopFront(t *testing.T) {
  function Test_Queue_PushFront_PopBack (line 74) | func Test_Queue_PushFront_PopBack(t *testing.T) {
  function Test_Queue_PushBack_PopFront (line 80) | func Test_Queue_PushBack_PopFront(t *testing.T) {
  function Test_Queue_PushBack_PopBack (line 86) | func Test_Queue_PushBack_PopBack(t *testing.T) {

FILE: dlist_test.go
  function Test_Dlist_Interface (line 7) | func Test_Dlist_Interface(t *testing.T) {
  function Test_DList_New (line 11) | func Test_DList_New(t *testing.T) {
  function Test_DListOf (line 17) | func Test_DListOf(t *testing.T) {
  function Test_DList_String (line 23) | func Test_DList_String(t *testing.T) {
  function Test_DList_Iterate (line 28) | func Test_DList_Iterate(t *testing.T) {
  function Test_DList_Iterate_Empty (line 39) | func Test_DList_Iterate_Empty(t *testing.T) {
  function Test_DList_FrontBack (line 48) | func Test_DList_FrontBack(t *testing.T) {
  function Test_DList_PushFront (line 54) | func Test_DList_PushFront(t *testing.T) {
  function Test_DList_PushBack (line 61) | func Test_DList_PushBack(t *testing.T) {
  function Test_DList_PopFront (line 68) | func Test_DList_PopFront(t *testing.T) {
  function Test_DList_PopBack (line 86) | func Test_DList_PopBack(t *testing.T) {
  function Test_DList_PushBack_PopFront (line 104) | func Test_DList_PushBack_PopFront(t *testing.T) {
  function Test_DList_PushBack_PopBack (line 114) | func Test_DList_PushBack_PopBack(t *testing.T) {
  function Test_DList_PushFront_PopBack (line 121) | func Test_DList_PushFront_PopBack(t *testing.T) {
  function Test_DList_PushFront_PopFront (line 128) | func Test_DList_PushFront_PopFront(t *testing.T) {
  function Test_DList_ForEach (line 135) | func Test_DList_ForEach(t *testing.T) {
  function Test_DList_ForEachIf (line 146) | func Test_DList_ForEachIf(t *testing.T) {
  function Test_DList_ForEachMutable (line 156) | func Test_DList_ForEachMutable(t *testing.T) {
  function Test_DList_ForEachMutableIf (line 172) | func Test_DList_ForEachMutableIf(t *testing.T) {
  function Test_DList_ForEach_EmptyOK (line 182) | func Test_DList_ForEach_EmptyOK(t *testing.T) {
  function Benchmark_DList_Iterate (line 190) | func Benchmark_DList_Iterate(b *testing.B) {

FILE: functor.go
  function Less (line 4) | func Less[T Ordered](a, b T) bool {
  function Greater (line 9) | func Greater[T Ordered](a, b T) bool {
  function OrderedCompare (line 14) | func OrderedCompare[T Ordered](a, b T) int {

FILE: generate.go
  function Range (line 7) | func Range[T Numeric](first, last T) []T {
  function Generate (line 18) | func Generate[T any](a []T, gen func() T) {

FILE: generate_test.go
  function Test_Range (line 5) | func Test_Range(t *testing.T) {
  function Test_Generate (line 12) | func Test_Generate(t *testing.T) {

FILE: heap.go
  function MakeMinHeap (line 8) | func MakeMinHeap[T Ordered](array []T) {
  function IsMinHeap (line 19) | func IsMinHeap[T Ordered](array []T) bool {
  function PushMinHeap (line 36) | func PushMinHeap[T Ordered](heap *[]T, v T) {
  function PopMinHeap (line 44) | func PopMinHeap[T Ordered](heap *[]T) T {
  function RemoveMinHeap (line 56) | func RemoveMinHeap[T Ordered](heap *[]T, i int) T {
  function heapSwap (line 69) | func heapSwap[T any](heap []T, i, j int) {
  function heapUp (line 73) | func heapUp[T Ordered](heap []T, j int) {
  function heapDown (line 84) | func heapDown[T Ordered](heap []T, i0, n int) bool {
  function MakeHeapFunc (line 107) | func MakeHeapFunc[T any](array []T, less LessFn[T]) {
  function IsHeapFunc (line 118) | func IsHeapFunc[T any](array []T, less LessFn[T]) bool {
  function PushHeapFunc (line 136) | func PushHeapFunc[T any](heap *[]T, v T, less LessFn[T]) {
  function PopHeapFunc (line 144) | func PopHeapFunc[T any](heap *[]T, less LessFn[T]) T {
  function RemoveHeapFunc (line 156) | func RemoveHeapFunc[T any](heap *[]T, i int, less LessFn[T]) T {
  function heapUpFunc (line 169) | func heapUpFunc[T any](heap []T, j int, less LessFn[T]) {
  function heapDownFunc (line 180) | func heapDownFunc[T any](heap []T, i0, n int, less LessFn[T]) bool {

FILE: heap_bench_test.go
  type intHeap (line 9) | type intHeap
    method Len (line 11) | func (h intHeap) Len() int           { return len(h) }
    method Less (line 12) | func (h intHeap) Less(i, j int) bool { return h[i] < h[j] }
    method Swap (line 13) | func (h intHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
    method Push (line 14) | func (h *intHeap) Push(x any)        { *h = append(*h, x.(int)) }
    method Pop (line 16) | func (h *intHeap) Pop() any {
  function BenchmarkHeapInit (line 24) | func BenchmarkHeapInit(b *testing.B) {
  function BenchmarkHeapPush (line 51) | func BenchmarkHeapPush(b *testing.B) {
  function BenchmarkHeapPop (line 82) | func BenchmarkHeapPop(b *testing.B) {

FILE: heap_test.go
  function TestMakeMinHeap (line 7) | func TestMakeMinHeap(t *testing.T) {
  function TestIsMinHeap (line 14) | func TestIsMinHeap(t *testing.T) {
  function TestMakeHeapFunc (line 21) | func TestMakeHeapFunc(t *testing.T) {
  function Test_MinHeap_PushPop (line 28) | func Test_MinHeap_PushPop(t *testing.T) {
  function Test_HeapFunc_PushPop (line 35) | func Test_HeapFunc_PushPop(t *testing.T) {
  function Test_MinHeap_Remove (line 44) | func Test_MinHeap_Remove(t *testing.T) {
  function Test_HeapFunc_Remove (line 51) | func Test_HeapFunc_Remove(t *testing.T) {

FILE: helper.go
  function nameOfType (line 8) | func nameOfType[T any]() string {

FILE: iterator.go
  type Iterator (line 4) | type Iterator interface
  type MutableIterator (line 11) | type MutableIterator interface
  type MapIterator (line 17) | type MapIterator interface
  type MutableMapIterator (line 23) | type MutableMapIterator interface

FILE: lookup.go
  function Max (line 6) | func Max[T Ordered](a, b T) T {
  function Min (line 16) | func Min[T Ordered](a, b T) T {
  function MaxN (line 26) | func MaxN[T Ordered](a ...T) T {
  function MinN (line 42) | func MinN[T Ordered](a ...T) T {
  function MinMax (line 58) | func MinMax[T Ordered](a, b T) (min, max T) {
  function MinMaxN (line 68) | func MinMaxN[T Ordered](a ...T) (min, max T) {
  function Find (line 90) | func Find[T comparable](a []T, x T) (index int, ok bool) {
  function FindIf (line 104) | func FindIf[T any](a []T, cond func(T) bool) (index int, ok bool) {
  function Index (line 118) | func Index[T comparable](a []T, x T) int {
  function AllOf (line 130) | func AllOf[T any](a []T, pred func(T) bool) bool {
  function AnyOf (line 142) | func AnyOf[T any](a []T, pred func(T) bool) bool {
  function NoneOf (line 154) | func NoneOf[T any](a []T, pred func(T) bool) bool {

FILE: lookup_test.go
  function Test_Min (line 5) | func Test_Min(t *testing.T) {
  function Test_Max (line 12) | func Test_Max(t *testing.T) {
  function Test_MinN (line 19) | func Test_MinN(t *testing.T) {
  function Test_MaxN (line 27) | func Test_MaxN(t *testing.T) {
  function Test_MinMax (line 35) | func Test_MinMax(t *testing.T) {
  function Test_MinMaxN (line 44) | func Test_MinMaxN(t *testing.T) {
  function Test_Find (line 51) | func Test_Find(t *testing.T) {
  function Test_FindIf (line 60) | func Test_FindIf(t *testing.T) {
  function Test_Index (line 70) | func Test_Index(t *testing.T) {
  function isNegative (line 82) | func isNegative(n int) bool { return n < 0 }
  function Test_AllOf (line 84) | func Test_AllOf(t *testing.T) {
  function Test_AnyOf (line 90) | func Test_AnyOf(t *testing.T) {
  function Test_NoneOf (line 96) | func Test_NoneOf(t *testing.T) {

FILE: pool.go
  type Pool (line 6) | type Pool
  function MakePool (line 9) | func MakePool[T any]() Pool[T] {
  function MakePoolWithNew (line 14) | func MakePoolWithNew[T any](new func() *T) Pool[T] {
  method Get (line 22) | func (pool *Pool[T]) Get() *T {
  method Put (line 31) | func (pool *Pool[T]) Put(x *T) {
  method untyped (line 37) | func (pool *Pool[T]) untyped() *sync.Pool {

FILE: pool_test.go
  function TestPool (line 5) | func TestPool(t *testing.T) {
  function TestMakePoolWithNew (line 11) | func TestMakePoolWithNew(t *testing.T) {
  function TestMakePoolNil (line 17) | func TestMakePoolNil(t *testing.T) {

FILE: priority_queue.go
  type PriorityQueue (line 6) | type PriorityQueue struct
  function NewPriorityQueue (line 12) | func NewPriorityQueue[T Ordered]() *PriorityQueue[T] {
  function NewPriorityQueueOn (line 20) | func NewPriorityQueueOn[T Ordered](slice []T) *PriorityQueue[T] {
  function NewPriorityQueueOf (line 29) | func NewPriorityQueueOf[T Ordered](elements ...T) *PriorityQueue[T] {
  function NewPriorityQueueFunc (line 34) | func NewPriorityQueueFunc[T any](less LessFn[T]) *PriorityQueue[T] {
  method Len (line 42) | func (pq *PriorityQueue[T]) Len() int {
  method IsEmpty (line 47) | func (pq *PriorityQueue[T]) IsEmpty() bool {
  method Clear (line 52) | func (pq *PriorityQueue[T]) Clear() {
  method Top (line 57) | func (pq *PriorityQueue[T]) Top() T {
  method Push (line 62) | func (pq *PriorityQueue[T]) Push(v T) {
  method Pop (line 67) | func (pq *PriorityQueue[T]) Pop() T {
  type pqImpl (line 71) | type pqImpl interface
  type pqOrdered (line 76) | type pqOrdered struct
  method Push (line 80) | func (pq *pqOrdered[T]) Push(v T) {
  method Pop (line 84) | func (pq *pqOrdered[T]) Pop() T {
  type pqFunc (line 89) | type pqFunc struct
  method Push (line 94) | func (pq *pqFunc[T]) Push(v T) {
  method Pop (line 98) | func (pq *pqFunc[T]) Pop() T {

FILE: priority_queue_test.go
  function TestInterface (line 8) | func TestInterface(t *testing.T) {
  function TestNewPriorityQueue (line 12) | func TestNewPriorityQueue(t *testing.T) {
  function TestNewPriorityQueueOf (line 18) | func TestNewPriorityQueueOf(t *testing.T) {
  function TestPriorityQueue_PushPop (line 23) | func TestPriorityQueue_PushPop(t *testing.T) {
  function TestPriorityQueueFunc_PushPop (line 39) | func TestPriorityQueueFunc_PushPop(t *testing.T) {
  function TestPriorityQueue_Clear (line 53) | func TestPriorityQueue_Clear(t *testing.T) {
  function ExamplePriorityQueue (line 66) | func ExamplePriorityQueue() {

FILE: skiplist.go
  constant skipListMaxLevel (line 20) | skipListMaxLevel = 40
  type SkipList (line 28) | type SkipList struct
  function NewSkipList (line 40) | func NewSkipList[K Ordered, V any]() *SkipList[K, V] {
  function NewSkipListFromMap (line 48) | func NewSkipListFromMap[K Ordered, V any](m map[K]V) *SkipList[K, V] {
  function NewSkipListFunc (line 57) | func NewSkipListFunc[K any, V any](keyCmp CompareFn[K]) *SkipList[K, V] {
  method IsEmpty (line 66) | func (sl *SkipList[K, V]) IsEmpty() bool {
  method Len (line 71) | func (sl *SkipList[K, V]) Len() int {
  method Clear (line 76) | func (sl *SkipList[K, V]) Clear() {
  method Iterate (line 85) | func (sl *SkipList[K, V]) Iterate() MutableMapIterator[K, V] {
  method Insert (line 91) | func (sl *SkipList[K, V]) Insert(key K, value V) {
  method Find (line 122) | func (sl *SkipList[K, V]) Find(key K) *V {
  method Has (line 131) | func (sl *SkipList[K, V]) Has(key K) bool {
  method LowerBound (line 138) | func (sl *SkipList[K, V]) LowerBound(key K) MutableMapIterator[K, V] {
  method UpperBound (line 145) | func (sl *SkipList[K, V]) UpperBound(key K) MutableMapIterator[K, V] {
  method FindRange (line 150) | func (sl *SkipList[K, V]) FindRange(first, last K) MutableMapIterator[K,...
  method Remove (line 156) | func (sl *SkipList[K, V]) Remove(key K) bool {
  method ForEach (line 173) | func (sl *SkipList[K, V]) ForEach(op func(K, V)) {
  method ForEachMutable (line 180) | func (sl *SkipList[K, V]) ForEachMutable(op func(K, *V)) {
  method ForEachIf (line 187) | func (sl *SkipList[K, V]) ForEachIf(op func(K, V) bool) {
  method ForEachMutableIf (line 196) | func (sl *SkipList[K, V]) ForEachMutableIf(op func(K, *V) bool) {
  type skipListNode (line 206) | type skipListNode struct
  type skipListIterator (line 215) | type skipListIterator struct
  method IsNotEnd (line 219) | func (it *skipListIterator[K, V]) IsNotEnd() bool {
  method MoveToNext (line 223) | func (it *skipListIterator[K, V]) MoveToNext() {
  method Key (line 227) | func (it *skipListIterator[K, V]) Key() K {
  method Value (line 231) | func (it *skipListIterator[K, V]) Value() V {
  method Pointer (line 235) | func (it *skipListIterator[K, V]) Pointer() *V {
  type skipListImpl (line 245) | type skipListImpl interface
  method init (line 253) | func (sl *SkipList[K, V]) init() {
  method randomLevel (line 261) | func (sl *SkipList[K, V]) randomLevel() int {
  type skipListOrdered (line 280) | type skipListOrdered struct
  method findNode (line 284) | func (sl *skipListOrdered[K, V]) findNode(key K) *skipListNode[K, V] {
  method doFindNode (line 288) | func (sl *skipListOrdered[K, V]) doFindNode(key K, eq bool) *skipListNod...
  method lowerBound (line 312) | func (sl *skipListOrdered[K, V]) lowerBound(key K) *skipListNode[K, V] {
  method upperBound (line 316) | func (sl *skipListOrdered[K, V]) upperBound(key K) *skipListNode[K, V] {
  method findInsertPoint (line 326) | func (sl *skipListOrdered[K, V]) findInsertPoint(key K) (*skipListNode[K...
  method findRemovePoint (line 349) | func (sl *skipListOrdered[K, V]) findRemovePoint(key K) (*skipListNode[K...
  method findPrevNodes (line 358) | func (sl *skipListOrdered[K, V]) findPrevNodes(key K) []*skipListNode[K,...
  type skipListFunc (line 376) | type skipListFunc struct
  method findNode (line 381) | func (sl *skipListFunc[K, V]) findNode(key K) *skipListNode[K, V] {
  method lowerBound (line 389) | func (sl *skipListFunc[K, V]) lowerBound(key K) *skipListNode[K, V] {
  method upperBound (line 407) | func (sl *skipListFunc[K, V]) upperBound(key K) *skipListNode[K, V] {
  method findInsertPoint (line 417) | func (sl *skipListFunc[K, V]) findInsertPoint(key K) (*skipListNode[K, V...
  method findRemovePoint (line 441) | func (sl *skipListFunc[K, V]) findRemovePoint(key K) (*skipListNode[K, V...
  method findPrevNodes (line 450) | func (sl *skipListFunc[K, V]) findPrevNodes(key K) []*skipListNode[K, V] {

FILE: skiplist_bench_test.go
  constant benchInitSize (line 9) | benchInitSize  = 1000000
  constant benchBatchSize (line 10) | benchBatchSize = 10
  function newMapN (line 13) | func newMapN(n int) map[int]int {
  function BenchmarkSkipList_Iterate (line 21) | func BenchmarkSkipList_Iterate(b *testing.B) {
  function BenchmarkSkipList_Insert (line 31) | func BenchmarkSkipList_Insert(b *testing.B) {
  function BenchmarkMap_Insert (line 43) | func BenchmarkMap_Insert(b *testing.B) {
  function BenchmarkSkipList_Insert_Dup (line 55) | func BenchmarkSkipList_Insert_Dup(b *testing.B) {
  function BenchmarkMap_Insert_Dup (line 65) | func BenchmarkMap_Insert_Dup(b *testing.B) {
  function BenchmarkMap_Find (line 75) | func BenchmarkMap_Find(b *testing.B) {
  function BenchmarkSkipList_Find (line 85) | func BenchmarkSkipList_Find(b *testing.B) {
  function BenchmarkSkipListString (line 111) | func BenchmarkSkipListString(b *testing.B) {

FILE: skiplist_newnode.go
  function newSkipListNode (line 7) | func newSkipListNode[K any, V any](level int, key K, value V) *skipListN...

FILE: skiplist_set.go
  type SkipListSet (line 4) | type SkipListSet
  function NewSkipListSet (line 7) | func NewSkipListSet[K Ordered]() *SkipListSet[K] {
  function NewSkipListSetFunc (line 12) | func NewSkipListSetFunc[K any](cmp CompareFn[K]) *SkipListSet[K] {
  function NewSkipListSetOf (line 17) | func NewSkipListSetOf[K Ordered](elements ...K) *SkipListSet[K] {
  method IsEmpty (line 26) | func (s *SkipListSet[K]) IsEmpty() bool {
  method Len (line 31) | func (s *SkipListSet[K]) Len() int {
  method Clear (line 36) | func (s *SkipListSet[K]) Clear() {
  method Has (line 41) | func (s *SkipListSet[K]) Has(key K) bool {
  method Insert (line 46) | func (s *SkipListSet[K]) Insert(key K) bool {
  method InsertN (line 53) | func (s *SkipListSet[K]) InsertN(keys ...K) int {
  method Remove (line 62) | func (s *SkipListSet[K]) Remove(key K) bool {
  method RemoveN (line 67) | func (s *SkipListSet[K]) RemoveN(keys ...K) int {
  method Keys (line 76) | func (s *SkipListSet[K]) Keys() []K {
  method ForEach (line 83) | func (s *SkipListSet[K]) ForEach(f func(K)) {
  method ForEachIf (line 88) | func (s *SkipListSet[K]) ForEachIf(f func(K) bool) {
  method LowerBound (line 93) | func (s *SkipListSet[K]) LowerBound(key K) Iterator[K] {
  method UpperBound (line 98) | func (s *SkipListSet[K]) UpperBound(key K) Iterator[K] {
  method FindRange (line 103) | func (s *SkipListSet[K]) FindRange(first, last K) Iterator[K] {
  method asMap (line 108) | func (s *SkipListSet[K]) asMap() *SkipList[K, struct{}] {
  type skipListSetIterator (line 112) | type skipListSetIterator
  method IsNotEnd (line 114) | func (it *skipListSetIterator[K]) IsNotEnd() bool {
  method MoveToNext (line 118) | func (it *skipListSetIterator[K]) MoveToNext() {
  method Value (line 122) | func (it *skipListSetIterator[K]) Value() K {

FILE: skiplist_set_test.go
  function TestNewSkipList_Interface (line 7) | func TestNewSkipList_Interface(t *testing.T) {
  function TestNewSkipListSet (line 12) | func TestNewSkipListSet(t *testing.T) {
  function TestNewSkipListSetOf (line 18) | func TestNewSkipListSetOf(t *testing.T) {
  function TestNewSkipListSetFunc (line 23) | func TestNewSkipListSetFunc(t *testing.T) {
  function TestNewSkipListSet_Insert_Remove_Has (line 29) | func TestNewSkipListSet_Insert_Remove_Has(t *testing.T) {
  function TestNewSkipListSet_Clear (line 49) | func TestNewSkipListSet_Clear(t *testing.T) {
  function TestNewSkipListSet_InsertN (line 56) | func TestNewSkipListSet_InsertN(t *testing.T) {
  function TestNewSkipListSet_RemoveN (line 63) | func TestNewSkipListSet_RemoveN(t *testing.T) {
  function TestNewSkipListSet_ForEach (line 71) | func TestNewSkipListSet_ForEach(t *testing.T) {
  function TestNewSkipListSet_ForEachIf (line 78) | func TestNewSkipListSet_ForEachIf(t *testing.T) {
  function TestNewSkipList_Iterate (line 85) | func TestNewSkipList_Iterate(t *testing.T) {
  function TestSkipListSet_Iterater (line 96) | func TestSkipListSet_Iterater(t *testing.T) {

FILE: skiplist_test.go
  function TestSkipList_Interface (line 8) | func TestSkipList_Interface(t *testing.T) {
  function TestNewSkipListString (line 16) | func TestNewSkipListString(t *testing.T) {
  function testNewSkipListType (line 25) | func testNewSkipListType[T Numeric](t *testing.T) {
  function TestNewSkipListInt8 (line 35) | func TestNewSkipListInt8(t *testing.T)  { testNewSkipListType[int8](t) }
  function TestNewSkipListInt16 (line 36) | func TestNewSkipListInt16(t *testing.T) { testNewSkipListType[int16](t) }
  function TestNewSkipListInt32 (line 37) | func TestNewSkipListInt32(t *testing.T) { testNewSkipListType[int32](t) }
  function TestNewSkipListInt64 (line 38) | func TestNewSkipListInt64(t *testing.T) { testNewSkipListType[int64](t) }
  function TestNewSkipListUInt8 (line 40) | func TestNewSkipListUInt8(t *testing.T)  { testNewSkipListType[uint8](t) }
  function TestNewSkipListUInt16 (line 41) | func TestNewSkipListUInt16(t *testing.T) { testNewSkipListType[uint16](t) }
  function TestNewSkipListUInt32 (line 42) | func TestNewSkipListUInt32(t *testing.T) { testNewSkipListType[uint32](t) }
  function TestNewSkipListUInt64 (line 43) | func TestNewSkipListUInt64(t *testing.T) { testNewSkipListType[uint64](t) }
  function TestNewSkipListUIntPtr (line 45) | func TestNewSkipListUIntPtr(t *testing.T) { testNewSkipListType[uintptr]...
  function TestNewSkipListFloat32 (line 47) | func TestNewSkipListFloat32(t *testing.T) { testNewSkipListType[float32]...
  function TestNewSkipListFloat64 (line 48) | func TestNewSkipListFloat64(t *testing.T) { testNewSkipListType[float64]...
  function TestNewSkipListFunc (line 50) | func TestNewSkipListFunc(t *testing.T) {
  function TestNewSkipListFromMap (line 88) | func TestNewSkipListFromMap(t *testing.T) {
  function TestSkipList_Iterate (line 96) | func TestSkipList_Iterate(t *testing.T) {
  function testSkipListIterater (line 107) | func testSkipListIterater(t *testing.T, sl *SkipList[int, int]) {
  function TestSkipList_Iterater (line 131) | func TestSkipList_Iterater(t *testing.T) {
  function TestSkipList_Func_Iterater (line 136) | func TestSkipList_Func_Iterater(t *testing.T) {
  function TestSkipList_Insert (line 144) | func TestSkipList_Insert(t *testing.T) {
  function TestSkipList_Insert_Reverse (line 153) | func TestSkipList_Insert_Reverse(t *testing.T) {
  function TestSkipList_Insert_Dup (line 162) | func TestSkipList_Insert_Dup(t *testing.T) {
  function newSkipListN (line 170) | func newSkipListN(n int) *SkipList[int, int] {
  function TestSkipList_Remove (line 179) | func TestSkipList_Remove(t *testing.T) {
  function TestSkipList_Remove_Nonexist (line 188) | func TestSkipList_Remove_Nonexist(t *testing.T) {
  function TestSkipList_Remove_Level (line 197) | func TestSkipList_Remove_Level(t *testing.T) {
  function TestSkipList_Clean (line 206) | func TestSkipList_Clean(t *testing.T) {
  function TestSkipList_level (line 218) | func TestSkipList_level(t *testing.T) {
  function TestSkipList_newnode (line 230) | func TestSkipList_newnode(t *testing.T) {
  function TestSkipList_Find (line 239) | func TestSkipList_Find(t *testing.T) {
  function TestSkipList_Has (line 248) | func TestSkipList_Has(t *testing.T) {
  function TestSkipList_ForEach (line 255) | func TestSkipList_ForEach(t *testing.T) {
  function TestSkipList_ForEachIf (line 265) | func TestSkipList_ForEachIf(t *testing.T) {
  function TestSkipList_ForEachMutable (line 278) | func TestSkipList_ForEachMutable(t *testing.T) {
  function TestSkipList_ForEachMutableIf (line 288) | func TestSkipList_ForEachMutableIf(t *testing.T) {

FILE: slist.go
  type SList (line 4) | type SList struct
  type sListNode (line 10) | type sListNode struct
  function SListOf (line 16) | func SListOf[T any](values ...T) SList[T] {
  method IsEmpty (line 25) | func (l *SList[T]) IsEmpty() bool {
  method Len (line 30) | func (l *SList[T]) Len() int {
  method Clear (line 35) | func (l *SList[T]) Clear() {
  method Front (line 42) | func (l *SList[T]) Front() T {
  method Back (line 50) | func (l *SList[T]) Back() T {
  method PushFront (line 58) | func (l *SList[T]) PushFront(v T) {
  method PushBack (line 68) | func (l *SList[T]) PushBack(v T) {
  method PopFront (line 82) | func (l *SList[T]) PopFront() T {
  method Reverse (line 97) | func (l *SList[T]) Reverse() {
  method Values (line 113) | func (l *SList[T]) Values() []T {
  method ForEach (line 134) | func (l *SList[T]) ForEach(cb func(T)) {
  method ForEachIf (line 142) | func (l *SList[T]) ForEachIf(cb func(T) bool) {
  method ForEachMutable (line 151) | func (l *SList[T]) ForEachMutable(cb func(*T)) {
  method ForEachMutableIf (line 159) | func (l *SList[T]) ForEachMutableIf(cb func(*T) bool) {
  method Iterate (line 168) | func (l *SList[T]) Iterate() MutableIterator[T] {
  type sListIterator (line 173) | type sListIterator struct
  method IsNotEnd (line 177) | func (it *sListIterator[T]) IsNotEnd() bool {
  method MoveToNext (line 181) | func (it *sListIterator[T]) MoveToNext() {
  method Value (line 185) | func (it *sListIterator[T]) Value() T {
  method Pointer (line 189) | func (it *sListIterator[T]) Pointer() *T {

FILE: slist_test.go
  function Test_SList_Interface (line 7) | func Test_SList_Interface(t *testing.T) {
  function Test_SList_Clean (line 12) | func Test_SList_Clean(t *testing.T) {
  function Test_SList_Front (line 20) | func Test_SList_Front(t *testing.T) {
  function Test_SList_Back (line 39) | func Test_SList_Back(t *testing.T) {
  function Test_SList_PushFront (line 58) | func Test_SList_PushFront(t *testing.T) {
  function Test_SList_PushBack (line 67) | func Test_SList_PushBack(t *testing.T) {
  function Test_SList_PopFront (line 77) | func Test_SList_PopFront(t *testing.T) {
  function Test_SList_Reverse (line 88) | func Test_SList_Reverse(t *testing.T) {
  function Test_SList_ForEach (line 94) | func Test_SList_ForEach(t *testing.T) {
  function Test_SList_ForEachIf (line 104) | func Test_SList_ForEachIf(t *testing.T) {
  function Test_SList_ForEachMutable (line 115) | func Test_SList_ForEachMutable(t *testing.T) {
  function Test_SList_ForEachMutableIf (line 129) | func Test_SList_ForEachMutableIf(t *testing.T) {
  function Test_SList_Iterate (line 140) | func Test_SList_Iterate(t *testing.T) {

FILE: sort.go
  function IsSorted (line 10) | func IsSorted[T Ordered](a []T) bool {
  function IsDescSorted (line 27) | func IsDescSorted[T Ordered](a []T) bool {
  type ascSlice (line 41) | type ascSlice
  method Len (line 43) | func (x ascSlice[T]) Len() int           { return len(x) }
  method Less (line 44) | func (x ascSlice[T]) Less(i, j int) bool { return x[i] < x[j] }
  method Swap (line 45) | func (x ascSlice[T]) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
  function Sort (line 51) | func Sort[T Ordered](a []T) {
  function StableSort (line 59) | func StableSort[T Ordered](a []T) {
  type descSlice (line 63) | type descSlice
  method Len (line 65) | func (x descSlice[T]) Len() int           { return len(x) }
  method Less (line 66) | func (x descSlice[T]) Less(i, j int) bool { return x[i] > x[j] }
  method Swap (line 67) | func (x descSlice[T]) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
  function DescSort (line 73) | func DescSort[T Ordered](a []T) {
  function DescStableSort (line 81) | func DescStableSort[T Ordered](a []T) {
  type funcSortable (line 85) | type funcSortable struct
  method Len (line 90) | func (x funcSortable[T]) Len() int           { return len(x.e) }
  method Less (line 91) | func (x funcSortable[T]) Less(i, j int) bool { return x.less(x.e[i], x.e...
  method Swap (line 92) | func (x funcSortable[T]) Swap(i, j int)      { x.e[i], x.e[j] = x.e[j], ...
  function SortFunc (line 98) | func SortFunc[T any](a []T, less func(x, y T) bool) {
  function StableSortFunc (line 106) | func StableSortFunc[T any](a []T, less func(x, y T) bool) {

FILE: sort_test.go
  function Test_IsSorted (line 7) | func Test_IsSorted(t *testing.T) {
  function Test_IsDescSorted (line 14) | func Test_IsDescSorted(t *testing.T) {
  function Test_Sort (line 21) | func Test_Sort(t *testing.T) {
  function Test_DescSort (line 27) | func Test_DescSort(t *testing.T) {
  function Test_StableSort (line 33) | func Test_StableSort(t *testing.T) {
  function Test_DescStableSort (line 39) | func Test_DescStableSort(t *testing.T) {
  function greater (line 45) | func greater(x, y int) bool { return x > y }
  function Test_SortFunc (line 47) | func Test_SortFunc(t *testing.T) {
  function Test_StableSortFunc (line 53) | func Test_StableSortFunc(t *testing.T) {

FILE: stack.go
  type Stack (line 5) | type Stack struct
  function NewStack (line 10) | func NewStack[T any]() *Stack[T] {
  function NewStackCap (line 15) | func NewStackCap[T any](capicity int) *Stack[T] {
  method IsEmpty (line 20) | func (s Stack[T]) IsEmpty() bool {
  method Len (line 25) | func (s Stack[T]) Len() int {
  method Cap (line 30) | func (s Stack[T]) Cap() int {
  method Clear (line 35) | func (s *Stack[T]) Clear() {
  method Push (line 40) | func (s *Stack[T]) Push(t T) {
  method TryPop (line 45) | func (s *Stack[T]) TryPop() (val T, ok bool) {
  method Pop (line 58) | func (s *Stack[T]) Pop() T {
  method Top (line 67) | func (s Stack[T]) Top() T {

FILE: stack_test.go
  function Test_Stack_Interface (line 7) | func Test_Stack_Interface(t *testing.T) {
  function Test_NewStack (line 10) | func Test_NewStack(t *testing.T) {
  function Test_NewStackCap (line 17) | func Test_NewStackCap(t *testing.T) {
  function Test_StackCap (line 23) | func Test_StackCap(t *testing.T) {
  function Test_Stack_Clear (line 30) | func Test_Stack_Clear(t *testing.T) {
  function Test_Stack_Push (line 39) | func Test_Stack_Push(t *testing.T) {
  function Test_Stack_TryPop (line 47) | func Test_Stack_TryPop(t *testing.T) {
  function Test_Stack_Pop (line 57) | func Test_Stack_Pop(t *testing.T) {
  function Test_Stack_Top (line 65) | func Test_Stack_Top(t *testing.T) {

FILE: test_helper.go
  function report (line 8) | func report(t *testing.T, msg string) {
  function reportMismatch (line 13) | func reportMismatch[T comparable](t *testing.T, a T, op string, b T) {
  function expectEq (line 18) | func expectEq[T comparable](t *testing.T, a, b T) {
  function expectNe (line 25) | func expectNe[T comparable](t *testing.T, a, b T) {
  function expectLt (line 32) | func expectLt[T Ordered](t *testing.T, a, b T) {
  function expectGt (line 39) | func expectGt[T Ordered](t *testing.T, a, b T) {
  function expectLe (line 46) | func expectLe[T Ordered](t *testing.T, a, b T) {
  function expectGe (line 53) | func expectGe[T Ordered](t *testing.T, a, b T) {
  function expectTrue (line 60) | func expectTrue(t *testing.T, actual bool) {
  function expectFalse (line 67) | func expectFalse(t *testing.T, actual bool) {
  function expectPanic (line 74) | func expectPanic(t *testing.T, f func()) {

FILE: transform.go
  function Copy (line 8) | func Copy[T any](a []T) []T {
  function CopyTo (line 16) | func CopyTo[T any](a []T, to []T) []T {
  function Fill (line 24) | func Fill[T any](a []T, v T) {
  function FillPattern (line 42) | func FillPattern[T any](a []T, pattern []T) {
  function TransformTo (line 60) | func TransformTo[R any, T any](a []T, op func(T) R, b []R) []R {
  function Transform (line 71) | func Transform[T any](a []T, op func(T) T) {
  function TransformCopy (line 80) | func TransformCopy[R any, T any](a []T, op func(T) R) []R {
  function Replace (line 91) | func Replace[T comparable](a []T, old, new T) {
  function ReplaceIf (line 102) | func ReplaceIf[T any](a []T, pred func(v T) bool, new T) {
  function Unique (line 114) | func Unique[T comparable](a []T) []T {
  function UniqueCopy (line 134) | func UniqueCopy[T comparable](a []T) []T {
  function Remove (line 154) | func Remove[T comparable](a []T, x T) []T {
  function RemoveCopy (line 169) | func RemoveCopy[T comparable](a []T, x T) []T {
  function RemoveIf (line 183) | func RemoveIf[T any](a []T, cond func(T) bool) []T {
  function RemoveIfCopy (line 198) | func RemoveIfCopy[T any](a []T, cond func(T) bool) []T {
  function Shuffle (line 211) | func Shuffle[T any](a []T) {
  function Reverse (line 220) | func Reverse[T any](a []T) {
  function ReverseCopy (line 229) | func ReverseCopy[T any](a []T) []T {

FILE: transform_fillzero_clear.go
  function FillZero (line 9) | func FillZero[T any](a []T) {

FILE: transform_fillzero_old.go
  function FillZero (line 9) | func FillZero[T any](a []T) {

FILE: transform_test.go
  function Test_Copy (line 12) | func Test_Copy(t *testing.T) {
  function Test_CopyTo (line 18) | func Test_CopyTo(t *testing.T) {
  function Test_Fill (line 27) | func Test_Fill(t *testing.T) {
  function Test_FillZero (line 36) | func Test_FillZero(t *testing.T) {
  function naiveFill (line 42) | func naiveFill[T any](a []T, v T) {
  function BenchmarkFill (line 48) | func BenchmarkFill(b *testing.B) {
  function Test_FillPattern (line 62) | func Test_FillPattern(t *testing.T) {
  function Test_Transform (line 70) | func Test_Transform(t *testing.T) {
  function Test_TransformTo (line 78) | func Test_TransformTo(t *testing.T) {
  function Test_TransformCopy (line 92) | func Test_TransformCopy(t *testing.T) {
  function Test_Replace (line 100) | func Test_Replace(t *testing.T) {
  function Test_ReplaceIf (line 106) | func Test_ReplaceIf(t *testing.T) {
  function Test_Unique (line 112) | func Test_Unique(t *testing.T) {
  function Test_UniqueCopy (line 120) | func Test_UniqueCopy(t *testing.T) {
  function Test_Remove (line 129) | func Test_Remove(t *testing.T) {
  function Test_RemoveCopy (line 136) | func Test_RemoveCopy(t *testing.T) {
  function Test_RemoveIf (line 144) | func Test_RemoveIf(t *testing.T) {
  function Test_RemoveIfCopy (line 151) | func Test_RemoveIfCopy(t *testing.T) {
  function Test_Shuffle (line 159) | func Test_Shuffle(t *testing.T) {
  function Test_Reverse (line 164) | func Test_Reverse(t *testing.T) {
  function Test_Reverse_Odd (line 170) | func Test_Reverse_Odd(t *testing.T) {
  function Test_ReverseCopy (line 176) | func Test_ReverseCopy(t *testing.T) {

FILE: types.go
  type Signed (line 6) | type Signed interface
  type Unsigned (line 13) | type Unsigned interface
  type Integer (line 20) | type Integer interface
  type Float (line 27) | type Float interface
  type Ordered (line 35) | type Ordered interface
  type Numeric (line 40) | type Numeric interface
  type LessFn (line 45) | type LessFn
  type CompareFn (line 51) | type CompareFn
  type HashFn (line 54) | type HashFn

FILE: vector.go
  type Vector (line 7) | type Vector
  function MakeVector (line 10) | func MakeVector[T any]() Vector[T] {
  function MakeVectorCap (line 15) | func MakeVectorCap[T any](c int) Vector[T] {
  function VectorOf (line 21) | func VectorOf[T any](v ...T) Vector[T] {
  function AsVector (line 26) | func AsVector[T any](s []T) Vector[T] {
  method IsEmpty (line 31) | func (v *Vector[T]) IsEmpty() bool {
  method Len (line 36) | func (v *Vector[T]) Len() int {
  method Cap (line 41) | func (v *Vector[T]) Cap() int {
  method Clear (line 47) | func (v *Vector[T]) Clear() {
  method Reserve (line 58) | func (v *Vector[T]) Reserve(l int) {
  method Shrink (line 67) | func (v *Vector[T]) Shrink() {
  method At (line 75) | func (v *Vector[T]) At(i int) T {
  method Set (line 81) | func (v *Vector[T]) Set(i int, x T) {
  method PushBack (line 88) | func (v *Vector[T]) PushBack(x T) {
  method PopBack (line 95) | func (v *Vector[T]) PopBack() T {
  method TryPopBack (line 104) | func (v *Vector[T]) TryPopBack() (T, bool) {
  method Back (line 115) | func (v Vector[T]) Back() T {
  method Append (line 120) | func (v *Vector[T]) Append(x ...T) {
  method Insert (line 129) | func (v *Vector[T]) Insert(i int, x ...T) {
  method Remove (line 149) | func (v *Vector[T]) Remove(i int) {
  method RemoveRange (line 154) | func (v *Vector[T]) RemoveRange(i, j int) {
  method RemoveLength (line 161) | func (v *Vector[T]) RemoveLength(i int, len int) {
  method RemoveIf (line 166) | func (v *Vector[T]) RemoveIf(cond func(T) bool) {
  method ForEach (line 173) | func (v Vector[T]) ForEach(cb func(val T)) {
  method ForEachIf (line 181) | func (v Vector[T]) ForEachIf(cb func(val T) bool) {
  method ForEachMutable (line 190) | func (v Vector[T]) ForEachMutable(cb func(val *T)) {
  method ForEachMutableIf (line 198) | func (v Vector[T]) ForEachMutableIf(cb func(val *T) bool) {
  method Iterate (line 207) | func (v Vector[T]) Iterate() MutableIterator[T] {
  method IterateRange (line 212) | func (v Vector[T]) IterateRange(i, j int) MutableIterator[T] {
  type vectorIterator (line 216) | type vectorIterator struct
  method Value (line 221) | func (it vectorIterator[T]) Value() T {
  method Pointer (line 225) | func (it vectorIterator[T]) Pointer() *T {
  method IsNotEnd (line 229) | func (it vectorIterator[T]) IsNotEnd() bool {
  method MoveToNext (line 233) | func (it *vectorIterator[T]) MoveToNext() {

FILE: vector_test.go
  function Test_Vector_Interface (line 7) | func Test_Vector_Interface(t *testing.T) {
  function Test_MakeVector (line 12) | func Test_MakeVector(t *testing.T) {
  function Test_MakeVectorCap (line 21) | func Test_MakeVectorCap(t *testing.T) {
  function Test_VectorOf (line 27) | func Test_VectorOf(t *testing.T) {
  function Test_AsVector (line 36) | func Test_AsVector(t *testing.T) {
  function Test_VectorCap (line 43) | func Test_VectorCap(t *testing.T) {
  function Test_Vector_Clear (line 51) | func Test_Vector_Clear(t *testing.T) {
  function Test_Vector_Reserve (line 59) | func Test_Vector_Reserve(t *testing.T) {
  function Test_Vector_Shrink (line 68) | func Test_Vector_Shrink(t *testing.T) {
  function Test_Vector_At_Set (line 76) | func Test_Vector_At_Set(t *testing.T) {
  function Test_Vector_PushBack (line 85) | func Test_Vector_PushBack(t *testing.T) {
  function Test_Vector_PopBack (line 91) | func Test_Vector_PopBack(t *testing.T) {
  function Test_Vector_PopBack_Clear (line 103) | func Test_Vector_PopBack_Clear(t *testing.T) {
  function Test_Vector_Back (line 110) | func Test_Vector_Back(t *testing.T) {
  function Test_Vector_Insert (line 117) | func Test_Vector_Insert(t *testing.T) {
  function Test_Vector_Insert_Tail (line 123) | func Test_Vector_Insert_Tail(t *testing.T) {
  function Test_Vector_Insert_Mid (line 129) | func Test_Vector_Insert_Mid(t *testing.T) {
  function Test_Vector_Insert_Cap (line 135) | func Test_Vector_Insert_Cap(t *testing.T) {
  function Test_Vector_Remove (line 142) | func Test_Vector_Remove(t *testing.T) {
  function Test_Vector_RemoveRange (line 153) | func Test_Vector_RemoveRange(t *testing.T) {
  function Test_Vector_RemoveLength (line 165) | func Test_Vector_RemoveLength(t *testing.T) {
  function Test_Vector_RemoveIf (line 177) | func Test_Vector_RemoveIf(t *testing.T) {
  function Test_Vector_ForEach (line 189) | func Test_Vector_ForEach(t *testing.T) {
  function Test_Vector_ForEachIf (line 200) | func Test_Vector_ForEachIf(t *testing.T) {
  function Test_Vector_ForEachMutable (line 210) | func Test_Vector_ForEachMutable(t *testing.T) {
  function Test_Vector_ForEachMutableIf (line 222) | func Test_Vector_ForEachMutableIf(t *testing.T) {
  function Test_Vector_Iterate (line 232) | func Test_Vector_Iterate(t *testing.T) {
  function Test_Vector_IterateRange (line 243) | func Test_Vector_IterateRange(t *testing.T) {