golang-set
A simple, battle-tested and generic set type for the Go language. Trusted by Docker, 1Password, Ethereum and Hashicorp.
Top Related Projects
GoDS (Go Data Structures) - Sets, Lists, Stacks, Maps, Trees, Queues, and much more
Quick Overview
deckarep/golang-set is a simple, high-performance set implementation for Go. It provides a thread-safe and non-thread-safe version of sets, allowing developers to work with unique collections of elements efficiently. The library offers a comprehensive set of operations and methods for manipulating and querying sets.
Pros
- Thread-safe and non-thread-safe implementations available
- Comprehensive set of operations (union, intersection, difference, etc.)
- Efficient performance for large sets
- Well-documented and easy to use
Cons
- Limited to storing elements of type
interface{}
- No built-in support for custom hash functions
- May require type assertions when retrieving elements
- Not part of the Go standard library, requiring external dependency management
Code Examples
- Creating and adding elements to a set:
set := mapset.NewSet()
set.Add(1)
set.Add(2)
set.Add(3)
fmt.Println(set.Contains(2)) // Output: true
fmt.Println(set.Cardinality()) // Output: 3
- Performing set operations:
set1 := mapset.NewSetWith(1, 2, 3)
set2 := mapset.NewSetWith(3, 4, 5)
union := set1.Union(set2)
intersection := set1.Intersect(set2)
difference := set1.Difference(set2)
fmt.Println(union) // Output: Set{1, 2, 3, 4, 5}
fmt.Println(intersection) // Output: Set{3}
fmt.Println(difference) // Output: Set{1, 2}
- Iterating over a set:
set := mapset.NewSetWith("apple", "banana", "cherry")
set.Each(func(elem interface{}) bool {
fmt.Println(elem)
return false // Continue iteration
})
// Output:
// apple
// banana
// cherry
Getting Started
To use deckarep/golang-set in your Go project, follow these steps:
-
Install the package:
go get github.com/deckarep/golang-set/v2
-
Import the package in your Go code:
import ( mapset "github.com/deckarep/golang-set/v2" )
-
Start using the set implementation:
set := mapset.NewSet[string]() set.Add("example") fmt.Println(set.Contains("example")) // Output: true
Competitor Comparisons
GoDS (Go Data Structures) - Sets, Lists, Stacks, Maps, Trees, Queues, and much more
Pros of gods
- Offers a wider variety of data structures (lists, stacks, maps, trees) beyond just sets
- Provides both thread-safe and non-thread-safe implementations
- Includes sorting algorithms and utility functions
Cons of gods
- May be overkill if you only need set functionality
- Potentially higher memory footprint due to the broader scope of the library
- Less focused on set-specific optimizations
Code Comparison
golang-set:
set := mapset.NewSet()
set.Add("apple")
set.Add("banana")
fmt.Println(set.Contains("apple")) // true
gods:
set := treeset.NewWithStringComparator()
set.Add("apple")
set.Add("banana")
fmt.Println(set.Contains("apple")) // true
Both libraries provide similar basic set functionality, but gods offers more flexibility in terms of set implementation (e.g., using a tree-based set). golang-set focuses solely on set operations, while gods provides a broader range of data structures and algorithms.
The choice between these libraries depends on your specific needs. If you require only set functionality, golang-set might be more suitable. However, if you need a comprehensive collection of data structures and algorithms, gods could be a better option.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
golang-set
The missing generic
set collection for the Go language. Until Go has sets built-in...use this.
Psst
- Hi there, ð! Do you use or have interest in the Zig programming language created by Andrew Kelley? If so, the golang-set project has a new sibling project: ziglang-set! Come check it out!
Update 3/5/2023
- Packaged version:
2.2.0
release includes a refactor to minimize pointer indirection, better method documentation standards and a few constructor convenience methods to increase ergonomics when appending itemsAppend
or creating a new set from an existMap
. - supports
new generic
syntax - Go
1.18.0
or higher - Workflow tested on Go
1.20
Coming from Python one of the things I miss is the superbly wonderful set collection. This is my attempt to mimic the primary features of the set collection from Python. You can of course argue that there is no need for a set in Go, otherwise the creators would have added one to the standard library. To those I say simply ignore this repository and carry-on and to the rest that find this useful please contribute in helping me make it better by contributing with suggestions or PRs.
Install
Use go get
to install this package.
go get github.com/deckarep/golang-set/v2
Features
- NEW Generics based implementation (requires Go 1.18 or higher)
- One common interface to both implementations
- a non threadsafe implementation favoring performance
- a threadsafe implementation favoring concurrent use
- Feature complete set implementation modeled after Python's set implementation.
- Exhaustive unit-test and benchmark suite
Trusted by
This package is trusted by many companies and thousands of open-source packages. Here are just a few sample users of this package.
- Notable projects/companies using this package
- Ethereum
- Docker
- 1Password
- Hashicorp
Star History
Usage
The code below demonstrates how a Set collection can better manage data and actually minimize boilerplate and needless loops in code. This package now fully supports generic syntax so you are now able to instantiate a collection for any comparable type object.
What is considered comparable in Go?
Booleans
,integers
,strings
,floats
or basically primitive types.Pointers
Arrays
Structs
if all of their fields are also comparable independently
Using this library is as simple as creating either a threadsafe or non-threadsafe set and providing a comparable
type for instantiation of the collection.
// Syntax example, doesn't compile.
mySet := mapset.NewSet[T]() // where T is some concrete comparable type.
// Therefore this code creates an int set
mySet := mapset.NewSet[int]()
// Or perhaps you want a string set
mySet := mapset.NewSet[string]()
type myStruct struct {
name string
age uint8
}
// Alternatively a set of structs
mySet := mapset.NewSet[myStruct]()
// Lastly a set that can hold anything using the any or empty interface keyword: interface{}. This is effectively removes type safety.
mySet := mapset.NewSet[any]()
Comprehensive Example
package main
import (
"fmt"
mapset "github.com/deckarep/golang-set/v2"
)
func main() {
// Create a string-based set of required classes.
required := mapset.NewSet[string]()
required.Add("cooking")
required.Add("english")
required.Add("math")
required.Add("biology")
// Create a string-based set of science classes.
sciences := mapset.NewSet[string]()
sciences.Add("biology")
sciences.Add("chemistry")
// Create a string-based set of electives.
electives := mapset.NewSet[string]()
electives.Add("welding")
electives.Add("music")
electives.Add("automotive")
// Create a string-based set of bonus programming classes.
bonus := mapset.NewSet[string]()
bonus.Add("beginner go")
bonus.Add("python for dummies")
}
Create a set of all unique classes. Sets will automatically deduplicate the same data.
all := required
.Union(sciences)
.Union(electives)
.Union(bonus)
fmt.Println(all)
Output:
Set{cooking, english, math, chemistry, welding, biology, music, automotive, beginner go, python for dummies}
Is cooking considered a science class?
result := sciences.Contains("cooking")
fmt.Println(result)
Output:
false
Show me all classes that are not science classes, since I don't enjoy science.
notScience := all.Difference(sciences)
fmt.Println(notScience)
Set{ music, automotive, beginner go, python for dummies, cooking, english, math, welding }
Which science classes are also required classes?
reqScience := sciences.Intersect(required)
Output:
Set{biology}
How many bonus classes do you offer?
fmt.Println(bonus.Cardinality())
Output:
2
Thanks for visiting!
-deckarep
Top Related Projects
GoDS (Go Data Structures) - Sets, Lists, Stacks, Maps, Trees, Queues, and much more
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot