cutil

Documentation

Index

• func BoolCmp(a, b bool) int
• func Complex128Cmp(a, b complex128) int
• func Complex64Cmp(a, b complex64) int
• func MapIntersect[M ~map[K]V, K, V comparable](a, b M) M
• func MapKeyValues[M ~map[K]V, K comparable, V any](m M) ([]K, []V)
• func MapKeys[M ~map[K]V, K comparable, V any](m M) []K
• func MapOrderedKeyValues[M ~map[K]V, K cmp.Ordered, V any](m M) ([]K, []V)
• func MapOrderedKeys[M ~map[K]V, K cmp.Ordered, V any](m M) []K
• func MapOrderedValues[M ~map[K]V, K cmp.Ordered, V any](m M) []V
• func MapUnion[M ~map[K]V, K comparable, V any](a, b M) M
• func MapValues[M ~map[K]V, K comparable, V any](m M) []V
• func OrderedCmp[T cmp.Ordered](a, b T) int
• func ReverseOrderedCmp[T cmp.Ordered](a, b T) int
• func ZeroOf[T any]() T
• type Comparable
• type Comparator
  • func Reversed[T any](cmp Comparator[T]) Comparator[T]
• type Complex
• type Iterator
• type KeyValVisitor
• type Pair
  • func MakePair[T1, T2 any](a T1, b T2) Pair[T1, T2]
• type Range
  • func (r *Range) Mid() int
  • func (r *Range) Rand() int
• type Visitor

Functions

func BoolCmp

func BoolCmp(a, b bool) int

func Complex128Cmp

func Complex128Cmp(a, b complex128) int

func Complex64Cmp

func Complex64Cmp(a, b complex64) int

func MapIntersect

func MapIntersect[M ~map[K]V, K, V comparable](a, b M) M

MapIntersect 返回两个map的交集, a ∩ b

func MapKeyValues

func MapKeyValues[M ~map[K]V, K comparable, V any](m M) ([]K, []V)

MapKeyValues 返回map的key和value列表

func MapKeys

func MapKeys[M ~map[K]V, K comparable, V any](m M) []K

MapKeys 返回map的key列表

func MapOrderedKeyValues

func MapOrderedKeyValues[M ~map[K]V, K cmp.Ordered, V any](m M) ([]K, []V)

MapOrderedKeyValues 返回map里已排序的key和value列表

func MapOrderedKeys

func MapOrderedKeys[M ~map[K]V, K cmp.Ordered, V any](m M) []K

MapOrderedKeys 返回map里已排序的key列表

func MapOrderedValues

func MapOrderedValues[M ~map[K]V, K cmp.Ordered, V any](m M) []V

MapOrderedValues 返回map里按key排序的value列表

func MapUnion

func MapUnion[M ~map[K]V, K comparable, V any](a, b M) M

MapUnion 返回两个map的并集, copy of a ∪ b

func MapValues

func MapValues[M ~map[K]V, K comparable, V any](m M) []V

MapValues 返回map的value列表

func OrderedCmp

func OrderedCmp[T cmp.Ordered](a, b T) int

func ReverseOrderedCmp

func ReverseOrderedCmp[T cmp.Ordered](a, b T) int

func ZeroOf

func ZeroOf[T any]() T

Types

type Comparable

type Comparable interface {
	// CompareTo returns an integer comparing two Comparables.
	// a.CompareTo(b) < 0 implies a < b
	// a.CompareTo(b) > 0 implies a > b
	// a.CompareTo(b) == 0 implies a == b
	CompareTo(b Comparable) int
}

Comparable compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second. The implementor must ensure that signum(compare(x, y)) == -signum(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.) The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0. Finally, the implementor must ensure that compare(x, y)==0 implies that signum(compare(x, z))==signum(compare(y, z)) for all z.

type Comparator

type Comparator[T any] func(a, b T) int

Comparator compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second. In the foregoing description, the notation sgn(expression) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.

The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.) The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0. Finally, the implementor must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z. It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact.

func Reversed

func Reversed[T any](cmp Comparator[T]) Comparator[T]

type Complex

type Complex interface {
	~complex64 | ~complex128
}

type Iterator

type Iterator[T any] interface {
	// HasNext returns true if the iteration has more elements.
	HasNext() bool

	// Next returns the next element in the iteration.
	Next() T

	// Remove removes from the underlying collection the last element returned by this iterator.
	Remove()
}

type KeyValVisitor

type KeyValVisitor[K, V any] func(key K, value V) bool

type Pair

type Pair[T1, T2 any] struct {
	First  T1
	Second T2
}

Pair is a type that provides a way to store two heterogeneous objects as a single unit.

func MakePair

func MakePair[T1, T2 any](a T1, b T2) Pair[T1, T2]

MakePair creates a Pair object, deducing the target type from the types of arguments

type Range

type Range struct {
	Min int
	Max int
}

Range contains a min value and a max value

func (*Range) Mid

func (r *Range) Mid() int

Mid returns the middle value of the range

func (*Range) Rand

func (r *Range) Rand() int

Rand returns a random value in the range

type Visitor

type Visitor[V any] func(value V) bool