set

README

set

set is a data structure package written by Go. It provides some basic set functionalities of the user. It uses map data structure under the hood. It does not have any dependency.

Installation

go get github.com/gozeloglu/set

Example

package main

import (
    "fmt"
    "github.com/gozeloglu/set"
)

func main() {
	s := set.New(set.ThreadUnsafe)
	s.Add(123)

	exist := s.Contains(123)
	if !exist {
		fmt.Println("123 not exist")
	}

	s.Append(1, 2, 3, 4, "abc")    // Add multiple values
	values := []interface{}{"github", 100, 640, 0.43, false}
	s.Append(values...) // Append the array of elements 

	s.Remove(4)
	size := s.Size()
	fmt.Println(size)   // Prints 5

	s.Pop()    // Returns random value from the set
	s.Clear()
	fmt.Println(s.Size())   // Prints 0
	
	if s.Empty() {
            fmt.Println("set is empty")
        }   
}

Supported methods

• Add(val interface{})
• Append(val ...interface{})
• Remove(val interface{})
• Contains(val interface{})
• Size()
• Pop()
• Clear()
• Empty()
• Slice()
• Union()
• Intersection()
• Difference()
• IsSubset()
• IsSuperset()
• IsDisjoint()
• Equal()
• SymmetricDifference()

Tests

You can run the tests with the following command.

go test ./...

You can check the code coverage with the following commands:

go test -coverprofile=coverage.out
go tool cover -html=coverage.out -o coverage.html

LICENSE

MIT

Documentation

Overview

Package set is a set package provides set data structure for Go. It is written without any dependency.

package main

import (
	"fmt"
	"github.com/gozeloglu/set"
)

func main() {
	s := set.New(set.ThreadUnsafe)
	s.Add(123)

	exist := s.Contains(123)
	if !exist {
		fmt.Println("123 not exist")
	}

	s.Append(1, 2, 3, 4, "abc")    // Add multiple values
	values := []interface{}{"github", 100, 640, 0.43, false}
	s.Append(values...) // Append the array of elements

	s.Remove(4)
	size := s.Size()
	fmt.Println(size)   // Prints 5

	s.Pop()    // Returns random value from the set
	s.Clear()
	fmt.Println(s.Size())   // Prints 0
}

You can call the Union() method for creating a new Set which contains the all items from the set1 and set2. It concatenates two sets and creates a new one.

union := set1.Union(set2)

In order to take intersection of the sets, you can call the Intersection() method.

intersect := set1.Intersection(set2)

You can find the difference between sets by Difference() method.

// Returns a set that contains the items which are only contained in the set1.
diffSet := set1.Difference(set2)

You can check the set which is subset of the another set with IsSubset() method.

isSubset := set1.IsSubset(set2)	// Returns true is set1 is subset of set2.

You can check the set which is superset of the another set with IsSuperset() method.

isSuperset := set1.IsSuperset(set2)	// Returns true is set1 is superset of set2.

You can check whether the sets are equal with the Equal() method.

equal := set1.Equal(set2)	// Returns true if set1 and set2 values are exactly the same

You can check whether the sets are disjoint with IsDisjoint() method.

isDisjoint := set1.IsDisjoint(set2)	// Returns true is set1 and set2 are disjoint.

You can get the symmetric difference of two sets by SymmetricDifference() method.

// Returns a set which is the symmetric difference of the two sets.
symDiffSet := set1.SymmetricDifference(set2)

Index

• Constants
• type Set
  • func New(t setType) Set
• type ThreadSafeSet
  • func (s *ThreadSafeSet) Add(val interface{})
  • func (s *ThreadSafeSet) Append(values ...interface{})
  • func (s *ThreadSafeSet) Clear()
  • func (s *ThreadSafeSet) Contains(val interface{}) bool
  • func (s *ThreadSafeSet) Difference(set Set) Set
  • func (s *ThreadSafeSet) Empty() bool
  • func (s *ThreadSafeSet) Equal(set Set) bool
  • func (s *ThreadSafeSet) Intersection(set Set) Set
  • func (s *ThreadSafeSet) IsDisjoint(set Set) bool
  • func (s *ThreadSafeSet) IsSubset(set Set) bool
  • func (s *ThreadSafeSet) IsSuperset(set Set) bool
  • func (s *ThreadSafeSet) Pop() interface{}
  • func (s *ThreadSafeSet) Remove(val interface{})
  • func (s *ThreadSafeSet) Size() uint
  • func (s *ThreadSafeSet) Slice() []interface{}
  • func (s *ThreadSafeSet) SymmetricDifference(set Set) Set
  • func (s *ThreadSafeSet) Union(set Set) Set
• type ThreadUnsafeSet
  • func (s *ThreadUnsafeSet) Add(val interface{})
  • func (s *ThreadUnsafeSet) Append(values ...interface{})
  • func (s *ThreadUnsafeSet) Clear()
  • func (s ThreadUnsafeSet) Contains(val interface{}) bool
  • func (s *ThreadUnsafeSet) Difference(set Set) Set
  • func (s ThreadUnsafeSet) Empty() bool
  • func (s *ThreadUnsafeSet) Equal(set Set) bool
  • func (s *ThreadUnsafeSet) Intersection(set Set) Set
  • func (s *ThreadUnsafeSet) IsDisjoint(set Set) bool
  • func (s *ThreadUnsafeSet) IsSubset(set Set) bool
  • func (s *ThreadUnsafeSet) IsSuperset(set Set) bool
  • func (s ThreadUnsafeSet) Pop() interface{}
  • func (s *ThreadUnsafeSet) Remove(val interface{})
  • func (s ThreadUnsafeSet) Size() uint
  • func (s ThreadUnsafeSet) Slice() []interface{}
  • func (s *ThreadUnsafeSet) SymmetricDifference(set Set) Set
  • func (s ThreadUnsafeSet) Union(set Set) Set

Constants

const (
	// ThreadSafe is used in New() for creating ThreadSafeSet.
	ThreadSafe = iota

	// ThreadUnsafe is used in New() for creating ThreadUnsafeSet.
	ThreadUnsafe
)

Types

type Set

type Set interface {
	Add(val interface{})
	Append(val ...interface{})
	Remove(val interface{})
	Contains(val interface{}) bool
	Size() uint
	Pop() interface{}
	Clear()
	Empty() bool
	Slice() []interface{}
	Union(set Set) Set
	Intersection(set Set) Set
	Difference(set Set) Set
	IsSubset(set Set) bool
	IsSuperset(set Set) bool
	IsDisjoint(set Set) bool
	Equal(set Set) bool
	SymmetricDifference(set Set) Set
}

Set is set interface.

func New

func New(t setType) Set

New creates a set data structure regarding setType. You can call the New function with two different setType.

safeSet := New(set.ThreadSafe)	// Creates a thread-safe set.
unsafeSet := New(set.ThreadUnsafe)	// Creates a thread-unsafe set.

type ThreadSafeSet

type ThreadSafeSet struct {
	// contains filtered or unexported fields
}

ThreadSafeSet is a set type which provides the thread-safety.

func (*ThreadSafeSet) Add

func (s *ThreadSafeSet) Add(val interface{})

Add adds a new values to set.

func (*ThreadSafeSet) Append

func (s *ThreadSafeSet) Append(values ...interface{})

Append adds multiple values into set.

func (*ThreadSafeSet) Clear

func (s *ThreadSafeSet) Clear()

Clear removes everything from the set.

func (*ThreadSafeSet) Contains

func (s *ThreadSafeSet) Contains(val interface{}) bool

Contains checks the value whether exists in the set.

func (*ThreadSafeSet) Difference

func (s *ThreadSafeSet) Difference(set Set) Set

Difference takes the items that only is stored in s, receiver set. It returns a new set.

func (*ThreadSafeSet) Empty

func (s *ThreadSafeSet) Empty() bool

Empty checks whether the set is empty.

func (*ThreadSafeSet) Equal

func (s *ThreadSafeSet) Equal(set Set) bool

Equal checks whether both sets contain exactly the same values.

func (*ThreadSafeSet) Intersection

func (s *ThreadSafeSet) Intersection(set Set) Set

Intersection takes the common values from both sets and returns a new set that stores the common ones.

func (*ThreadSafeSet) IsDisjoint

func (s *ThreadSafeSet) IsDisjoint(set Set) bool

IsDisjoint returns true if none of the items are present in the sets.

func (*ThreadSafeSet) IsSubset

func (s *ThreadSafeSet) IsSubset(set Set) bool

IsSubset returns true if all items in the set exist in the given set. Otherwise, it returns false.

func (*ThreadSafeSet) IsSuperset

func (s *ThreadSafeSet) IsSuperset(set Set) bool

IsSuperset returns true if all items in the given set exist in the set. Otherwise, it returns false.

func (*ThreadSafeSet) Pop

func (s *ThreadSafeSet) Pop() interface{}

Pop returns a random value from the set. If there is no element in set, it returns nil. It does not remove any elements from the set.

func (*ThreadSafeSet) Remove

func (s *ThreadSafeSet) Remove(val interface{})

Remove deletes the given value.

func (*ThreadSafeSet) Size

func (s *ThreadSafeSet) Size() uint

Size returns the length of the set which means that number of value of the set.

func (*ThreadSafeSet) Slice

func (s *ThreadSafeSet) Slice() []interface{}

Slice returns the elements of the set as a slice. The slice type is interface{}. The elements can be in any order.

func (*ThreadSafeSet) SymmetricDifference

func (s *ThreadSafeSet) SymmetricDifference(set Set) Set

SymmetricDifference returns a set that contains from two sets, but not the items are present in both sets.

func (*ThreadSafeSet) Union

func (s *ThreadSafeSet) Union(set Set) Set

Union returns a new Set that contains all items from the receiver Set and all items from the given Set.

type ThreadUnsafeSet

type ThreadUnsafeSet struct {
	// contains filtered or unexported fields
}

ThreadUnsafeSet is a set type which does not provide the thread-safety.

func (*ThreadUnsafeSet) Add

func (s *ThreadUnsafeSet) Add(val interface{})

Add adds a new values to set if there is enough capacity. It is not a thread-safe method. It does not handle the concurrency.

Example:

s.Add("str")
s.Add(12)

func (*ThreadUnsafeSet) Append

func (s *ThreadUnsafeSet) Append(values ...interface{})

Append adds multiple values into set. It is not a thread-safe method. It does not handle the concurrency.

Example:

s.Append(1,2,3,4, true, false, "str")

func (*ThreadUnsafeSet) Clear

func (s *ThreadUnsafeSet) Clear()

Clear removes everything from the set. It is not a thread-safe method. It does not handle the concurrency.

Example:

s.Clear()

func (ThreadUnsafeSet) Contains

func (s ThreadUnsafeSet) Contains(val interface{}) bool

Contains checks the value whether exists in the set. It is not a thread-safe method. It does not handle the concurrency.

Example:

exist := s.Contains(1)

func (*ThreadUnsafeSet) Difference

func (s *ThreadUnsafeSet) Difference(set Set) Set

Difference takes the items that only is stored in s, receiver set. It returns a new set. It is not a thread-safe method. It does not handle the concurrency.

Example:

diffSet := s1.Difference(s2)

func (ThreadUnsafeSet) Empty

func (s ThreadUnsafeSet) Empty() bool

Empty checks whether the set is empty. It is not a thread-safe method. It does not handle the concurrency.

Example:

empty := s.Empty()

func (*ThreadUnsafeSet) Equal

func (s *ThreadUnsafeSet) Equal(set Set) bool

Equal checks whether both sets contain exactly the same values. It is not a thread-safe method. It does not handle the concurrency.

Example:

equal := s1.Equal(s2)

func (*ThreadUnsafeSet) Intersection

func (s *ThreadUnsafeSet) Intersection(set Set) Set

Intersection takes the common values from both sets and returns a new set that stores the common ones. It is not a thread-safe method. It does not handle the concurrency.

Example:

intersectionSet := s1.Intersection(s2)

func (*ThreadUnsafeSet) IsDisjoint

func (s *ThreadUnsafeSet) IsDisjoint(set Set) bool

IsDisjoint returns true if none of the items are present in the sets. It is not a thread-safe method. It does not handle the concurrency.

Example:

isDisjoint := s1.IsDisjoint(s2)

func (*ThreadUnsafeSet) IsSubset

func (s *ThreadUnsafeSet) IsSubset(set Set) bool

IsSubset returns true if all items in the set exist in the given set. Otherwise, it returns false. It is not a thread-safe method. It does not handle the concurrency.

Example:

isSubset := s1.IsSubset(s2)

func (*ThreadUnsafeSet) IsSuperset

func (s *ThreadUnsafeSet) IsSuperset(set Set) bool

IsSuperset returns true if all items in the given set exist in the set. Otherwise, it returns false. It is not a thread-safe method. It does not handle the concurrency.

Example:

isSuperset := s1.IsSuperset(s2)

func (ThreadUnsafeSet) Pop

func (s ThreadUnsafeSet) Pop() interface{}

Pop returns a random value from the set. If there is no element in set, it returns nil. It is not a thread-safe method. It does not handle the concurrency.

Example:

val := s.Pop()

func (*ThreadUnsafeSet) Remove

func (s *ThreadUnsafeSet) Remove(val interface{})

Remove deletes the given value. It is not a thread-safe method. It does not handle the concurrency.

Example:

s.Remove(2)

func (ThreadUnsafeSet) Size

func (s ThreadUnsafeSet) Size() uint

Size returns the length of the set which means that number of value of the set. It is not a thread-safe method. It does not handle the concurrency.

Example:

size := s.Size()

func (ThreadUnsafeSet) Slice

func (s ThreadUnsafeSet) Slice() []interface{}

Slice returns the elements of the set as a slice. The slice type is interface{}. The elements can be in any order. It is not a thread-safe method. It does not handle the concurrency.

Example:

setSlice := s.Slice()

func (*ThreadUnsafeSet) SymmetricDifference

func (s *ThreadUnsafeSet) SymmetricDifference(set Set) Set

SymmetricDifference returns a set that contains from two sets, but not the items are present in both sets. It is not a thread-safe method. It does not handle the concurrency.

Example:

symmetricDiffSet := s1.SymmetricDifference(s2)

func (ThreadUnsafeSet) Union

func (s ThreadUnsafeSet) Union(set Set) Set

Union returns a new Set that contains all items from the receiver Set and all items from the given Set. It is not a thread-safe method. It does not handle the concurrency.

Example:

unionSet := s1.Union(s2)