api

type BasicSet[C comparable] interface {
	// String returns the string representation of the set.
	// Example:
	//  { (), (), () }
	String() string
	// Len counts the elements in the set.
	Len() int
	// Elements returns the unique elements of the set.
	Elements() []C
	// Add unique elements to the set.
	// Repeated elements will be discarded.
	Add(elements ...C)
	// Contains checked whether all elements are in the set.
	Contains(elements ...C) bool
	// Remove any existing elements from the set.
	Remove(elements ...C)
}

type ElementSet[C comparable] interface {
	BasicSet[C]

	Union(other ElementSet[C]) ElementSet[C]
	Intersection(other ElementSet[C]) ElementSet[C]
	Difference(other ElementSet[C]) ElementSet[C]

	ThreeWay(other ElementSet[C]) [3]ElementSet[C]

	UnionWith(elements ...C) ElementSet[C]
	IntersectionWith(elements ...C) ElementSet[C]
	DifferenceWith(elements ...C) ElementSet[C]
}

type FloatingPoint interface{ ~float32 | ~float64 }

type GrowFlags int

type Integer interface {
	SignedInteger | UnsignedInteger
}

type Interval[T Number] interface {
	Min() T
	Max() T
	Len() T

	IsEmpty() bool
	IsSingleton() bool
	IsCompound() bool

	Enumerate(step T) []T
	Intervals() []Interval[T]

	Contains(value T) bool
	Overlaps(other Interval[T]) bool
	Equals(other Interval[T]) bool

	Union(other Interval[T]) Interval[T]
	Intersection(other Interval[T]) Interval[T]
	Difference(other Interval[T]) Interval[T]

	Resize(newSize T, growMode GrowFlags) Interval[T]
	Scale(scale float64, growMode GrowFlags) Interval[T]
	Translate(offset T, back bool) Interval[T]
}

type Number interface{ Integer | FloatingPoint }

type SignedInteger interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

type Unit = struct{}

type UnsignedInteger interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}