api

Documentation

Overview

Package api defines interfaces implemented by library structs and common types.

Index

• Variables
• type BasicSet
• type FloatingPoint
• type GrowFlags
• type Integer
• type Interval
• type Number
• type SignedInteger
• type Unit
• type UnsignedInteger

Variables

var U = Unit{}

U is the unit instance, representing the single instance of the type nothing.

Types

type BasicSet

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)
}

BasicSet is an interface for a basic implementation of a set of comparables.

type FloatingPoint

type FloatingPoint interface {
	~float32 | ~float64
}

type GrowFlags

type GrowFlags int

const (
	GROW_BOTH_OVERFLOW_RIGHT GrowFlags = 0
	GROW_LEFT_OVERFLOW_RIGHT GrowFlags = 1
	GROW_RIGHT_OVERFLOW_LEFT GrowFlags = 2
	GROW_BOTH_OVERFLOW_LEFT  GrowFlags = 3
	GROW_NO_OVERFLOW         GrowFlags = 4
)

type Integer

type Integer interface {
	SignedInteger | UnsignedInteger
}

type Interval

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

type Number interface {
	Integer | FloatingPoint
}

type SignedInteger

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

type Unit

type Unit = struct{}

Unit represents an empty struct for efficient representation of nothing.

type UnsignedInteger

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