algext

Documentation

Index

• func BoolCmp(a, b bool) int
• func Complex128Cmp(a, b complex128) int
• func Complex64Cmp(a, b complex64) int
• func OrderedCmp[T cmp.Ordered](a, b T) int
• func ReverseOrderedCmp[T cmp.Ordered](a, b T) int
• type Comparable
• type Comparator
  • func Reversed[T any](cmp Comparator[T]) Comparator[T]
• type Iterator
• type KeyValVisitor
• 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 OrderedCmp

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

func ReverseOrderedCmp

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

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 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 Visitor

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