remove unused code

lib/util/chans/try.go

-package chans
-
-func TrySend[T any](ch chan<- T, value T) bool {
-	select {
-	case ch <- value:
-		return true
-	default:
-		return false
-	}
-}
-
-func TryRecv[T any](ch <-chan T) (T, bool) {
-	select {
-	case value, ok := <-ch:
-		return value, ok
-	default:
-		return *new(T), false
-	}
-}

lib/util/dio/reader.go

-package dio
-
-import (
-	"io"
-	"time"
-)
-
-type Reader interface {
-	SetReadDeadline(deadline time.Time) error
-	io.Reader
-}

lib/util/dio/readwriter.go

-package dio
-
-import (
-	"time"
-)
-
-type ReadWriter interface {
-	SetDeadline(deadline time.Time) error
-	Reader
-	Writer
-}

lib/util/dio/writer.go

-package dio
-
-import (
-	"io"
-	"time"
-)
-
-type Writer interface {
-	SetWriteDeadline(deadline time.Time) error
-	io.Writer
-}

lib/util/maps/clear.go

-package maps
-
-func Clear[K comparable, V any](m map[K]V) {
-	for k := range m {
-		delete(m, k)
-	}
-}

lib/util/maps/clone.go

-package maps
-
-func Clone[K comparable, V any](value map[K]V) map[K]V {
-	if value == nil {
-		return nil
-	}
-	m := make(map[K]V, len(value))
-	for k, v := range value {
-		m[k] = v
-	}
-	return m
-}

lib/util/maths/clamp.go

-package maths
-
-func Clamp[T Ordered](x, min, max T) T {
-	return Min(Max(x, min), max)
-}

lib/util/maths/max.go

-package maths
-
-func Max[T Ordered](a, b T) T {
-	if a > b {
-		return a
-	}
-	return b
-}

lib/util/maths/min.go

-package maths
-
-func Min[T Ordered](a, b T) T {
-	if a < b {
-		return a
-	}
-	return b
-}

lib/util/maths/ordered.go

-package maths
-
-type Ordered interface {
-	~int | ~int8 | ~int16 | ~int32 | ~int64 |
-		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
-		~float32 | ~float64
-}

lib/util/queue/queue.go

-package queue
-
-import "sync"
-
-type LIFO[T any] struct {
-	items  []T
-	signal sync.Cond
-	mu     sync.Mutex
-}
-
-func (v *LIFO[T]) init() {
-	if v.signal.L == nil {
-		v.signal.L = &v.mu
-	}
-}
-
-func (v *LIFO[T]) Push(item T) {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	v.init()
-
-	v.items = append(v.items, item)
-	v.signal.Signal()
-}
-
-func (v *LIFO[T]) Pop() T {
-	v.mu.Lock()
-	defer v.mu.Unlock()
-	v.init()
-
-	for len(v.items) == 0 {
-		v.signal.Wait()
-	}
-	item := v.items[len(v.items)-1]
-	v.items = v.items[:len(v.items)-1]
-
-	return item
-}

lib/util/slices/cloneinto.go

-package slices
-
-func CloneInto[T any](dst, src []T) []T {
-	dst = Resize(dst, len(src))
-	for i, v := range src {
-		dst[i] = v
-	}
-	return dst
-}

lib/util/slices/equal.go

-package slices
-
-func Equal[T comparable](a, b []T) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := range a {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
-}