typemap

type AllKeyValues[T any, K any, V any] interface {
	AllKeyValues(T) iter.Seq2[K, V]
}

type AllKeys[T any, K any] interface {
	AllKeys(T) iter.Seq[K]
}

type AllValues[T any, V any] interface {
	AllValues(T) iter.Seq[V]
}

type Compare[T any] interface {
	Compare(T, T) bool
}

type DefaultCompare[T comparable] struct{}

type DefaultOrder[T cmp.Ordered] struct{}

type Deref[T any] interface {
	Deref(*T) T
}

type Float32 = FloatLike[float32]

type Float64 = FloatLike[float64]

type FloatLike[T ~float32 | ~float64] struct {
	StringFunc[T]
	DefaultCompare[T]
	DefaultOrder[T]
}

type ForInt = ForIntegerLike[int]

type ForInt16 = ForIntegerLike[int16]

type ForInt32 = ForIntegerLike[int32]

type ForInt64 = ForIntegerLike[int64]

type ForInt8 = ForIntegerLike[int8]

type ForIntegerLike[T ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr] struct {
	StringFunc[T]
	DefaultCompare[T]
	DefaultOrder[T]
}

type ForMap[K comparable, V any] = ForMapLike[map[K]V, K, V]

type ForMapLike[T ~map[K]V, K comparable, V any] struct {
	StringFunc[T]
}

type ForPointer[T any] struct {
	StringFunc[*T]
}

type ForSlice[E any] = ForSliceLike[[]E, E]

type ForSliceLike[T ~[]E, E any] struct {
	StringFunc[T]
}

type ForString = ForStringLike[string]

type ForStringLike[T ~string] struct {
	StringFunc[T]
	DefaultCompare[T]
	DefaultOrder[T]
}

type ForUint = ForIntegerLike[uint]

type ForUint16 = ForIntegerLike[uint16]

type ForUint32 = ForIntegerLike[uint32]

type ForUint64 = ForIntegerLike[uint64]

type ForUint8 = ForIntegerLike[uint8]

type ForUintptr = ForIntegerLike[uintptr]

type GetValue[T any, K any, V any] interface {
	GetValue(T, K) (V, bool)
}

type HasKey[T any, K any] interface {
	HasKey(T, K) bool
}

type IsNil[T any] interface {
	IsNil(t T) bool
}

type Length[T any] interface {
	Length(T) int
}

type Order[T any] interface {
	Order(T, T) int
}

type String[T any] interface {
	String(T) string
}

type StringFunc[T any] func(T) string