set

README

set

generic set types for golang

features

• both un-ordered and ordered types
• union, diff, intersect, comparision for any two sets
• simple API
• 100% test coverage

example

import (
    "fmt"

    "github.com/s0rg/set"
)

func main() {
    // create new, empty set of int's
    s := make(set.Unordered[int]) // fastest variant as it direct functions call

    // or

    // second (a bit slower) form for unordered constructor, it uses indirect calls via interface
    // s := set.NewUnordered[int]()

    // ordered constructor, only this form
    // s := set.NewOrdered[int]()

    // add some values
    s.Add(1)
    s.Add(2)

    // and some more...
    set.Load(s, 2, 3)

    // check set for value
    if !s.Has(2) {
        panic("2 not found")
    }

    // check and add
    if s.TryAdd(4) {
        fmt.Println("value 4 wasnt in set, it there now")
    }

    // delete item
    s.Del(1)

    fmt.Println("Set length:", s.Len())
    fmt.Println("Set contents:", s.ToSlice())

    s.Clear()

    fmt.Println("Set length:", s.Len())
    fmt.Println("Set contents:", s.ToSlice())
}

Documentation

Overview

Package set provides ordered and un-ordered generic sets, and handy operations between them.

Index

• func Contains[T comparable](a, b Set[T]) (yes bool)
• func ContainsAny[T comparable](a, b Set[T]) (yes bool)
• func Equal[T comparable](a, b Set[T]) (yes bool)
• func ToSlice[T comparable](s Set[T]) (rv []T)
• type Set
  • func Diff[T comparable](a, b Set[T]) (rv Set[T])
  • func Intersect[T comparable](a, b Set[T]) (rv Set[T])
  • func Load[T comparable](s Set[T], v ...T) Set[T]
  • func NewOrdered[T comparable]() Set[T]
  • func NewUnordered[T comparable]() Set[T]
  • func Union[T comparable](a, b Set[T]) (rv Set[T])
• type Unordered
  • func (u Unordered[T]) Add(v T) bool
  • func (u Unordered[T]) Clear()
  • func (u Unordered[T]) Clone() (rv Set[T])
  • func (u Unordered[T]) Del(v T)
  • func (u Unordered[T]) Has(v T) (ok bool)
  • func (u Unordered[T]) Iter(it func(T) bool)
  • func (u Unordered[T]) Len() int
  • func (u Unordered[T]) Pop() (v T, ok bool)

Functions

func Contains

func Contains[T comparable](a, b Set[T]) (yes bool)

Contains returns true if smallest of two sets (by length) fully contains inside bigger one, if sets equals in length the result is same as comparison.

func ContainsAny

func ContainsAny[T comparable](a, b Set[T]) (yes bool)

ContainsAny returns true if `a` has at least one element from `b`.

func Equal

func Equal[T comparable](a, b Set[T]) (yes bool)

Equal returns true if `a` and `b` has same length and elements.

func ToSlice

func ToSlice[T comparable](s Set[T]) (rv []T)

ToSlice returns set as slice of items.

Types

type Set

type Set[T comparable] interface {
	// Add adds item to the set.
	Add(T) bool
	// Has checks if item is already present.
	Has(T) bool
	// Del removes item, no-op if not present.
	Del(T)
	// Pop removes and returns an arbitrary item.
	Pop() (v T, ok bool)
	// Len returns current items count.
	Len() int
	// Clone returns shallow copy.
	Clone() Set[T]
	// Iter iterates items until callback returns false.
	Iter(func(T) bool)
	// Clear removes all items.
	Clear()
}

Set is the primary interface provided by the set package.

func Diff

func Diff[T comparable](a, b Set[T]) (rv Set[T])

Diff returns new set with elements from `a` that arent in `b`.

func Intersect

func Intersect[T comparable](a, b Set[T]) (rv Set[T])

Intersect returns new set with keys from `a` that present in `b`.

func Load

func Load[T comparable](s Set[T], v ...T) Set[T]

Load populates given set with values.

func NewOrdered

func NewOrdered[T comparable]() Set[T]

NewOrdered create empty ordered set for given type.

func NewUnordered

func NewUnordered[T comparable]() Set[T]

NewUnordered create empty unordered Set for given type.

func Union

func Union[T comparable](a, b Set[T]) (rv Set[T])

Union returns new set with elements from both sets.

type Unordered

type Unordered[T comparable] map[T]stub

Unordered is a simple and effective un-ordered generic set.

func (Unordered[T]) Add

func (u Unordered[T]) Add(v T) bool

Add implements Set interface.

func (Unordered[T]) Clear

func (u Unordered[T]) Clear()

Clear implements Set interface.

func (Unordered[T]) Clone

func (u Unordered[T]) Clone() (rv Set[T])

Clone implements Set interface.

func (Unordered[T]) Del

func (u Unordered[T]) Del(v T)

Del implements Set interface.

func (Unordered[T]) Has

func (u Unordered[T]) Has(v T) (ok bool)

Has implements Set interface.

func (Unordered[T]) Iter

func (u Unordered[T]) Iter(it func(T) bool)

Iter implements Set interface.

func (Unordered[T]) Len

func (u Unordered[T]) Len() int

Len implements Set interface.

func (Unordered[T]) Pop

func (u Unordered[T]) Pop() (v T, ok bool)

Pop implements Set interface.