hashmap

README

hashmap

An efficient hashmap implementation in Go.

Features

• Support for Generics (Go 1.18+).
• Map and Set types for unordered key-value maps and sets,
• xxhash algorithm
• Open addressing
• Robin hood hashing

Using

To start using this package, install Go and run:

$ go get github.com/tidwall/hashmap

Getting Started

Installing

To start using hashmap, install Go and run go get:

$ go get github.com/tidwall/hashmap

This will retrieve the library.

Usage

The Map type works similar to a standard Go map, and includes the methods: Set, Get, Delete, Len, and Scan.

var m hashmap.Map[string, string]
m.Set("Hello", "Dolly!")
val, _ := m.Get("Hello")
fmt.Printf("%v\n", val)
val, _ = m.Delete("Hello")
fmt.Printf("%v\n", val)
val, _ = m.Get("Hello")
fmt.Printf("%v\n", val)

// Output:
// Dolly!
// Dolly!
//

The Set type is like Map but only for keys. It includes the methods: Insert, Contains, Delete, Len, and Scan.

var m hashmap.Set[string]
m.Insert("Andy")
m.Insert("Kate")
m.Insert("Janet")

fmt.Printf("%v\n", m.Contains("Kate"))
fmt.Printf("%v\n", m.Contains("Bob"))
fmt.Printf("%v\n", m.Contains("Andy"))

// Output:
// true
// false
// true

Contact

Josh Baker @tidwall

License

Source code is available under the MIT License.

Documentation

Index

• type Map
  • func New[K comparable, V any](cap int) *Map[K, V]
  • func (m *Map[K, V]) Delete(key K) (prev V, deleted bool)
  • func (m *Map[K, V]) Get(key K) (value V, ok bool)
  • func (m *Map[K, V]) Len() int
  • func (m *Map[K, V]) Scan(iter func(key K, value V) bool)
  • func (m *Map[K, V]) Set(key K, value V) (V, bool)
• type Set
  • func (tr *Set[K]) Contains(key K) bool
  • func (tr *Set[K]) Delete(key K)
  • func (tr *Set[K]) Insert(key K)
  • func (tr *Set[K]) Len() int
  • func (tr *Set[K]) Scan(iter func(key K) bool)

Types

type Map

type Map[K comparable, V any] struct {
	// contains filtered or unexported fields
}

Map is a hashmap. Like map[string]interface{}

func New

func New[K comparable, V any](cap int) *Map[K, V]

New returns a new Map. Like map[string]interface{}

func (*Map[K, V]) Delete

func (m *Map[K, V]) Delete(key K) (prev V, deleted bool)

Delete deletes a value for a key. Returns the deleted value, or false when no value was assigned.

func (*Map[K, V]) Get

func (m *Map[K, V]) Get(key K) (value V, ok bool)

Get returns a value for a key. Returns false when no value has been assign for key.

func (*Map[K, V]) Len

func (m *Map[K, V]) Len() int

Len returns the number of values in map.

func (*Map[K, V]) Scan

func (m *Map[K, V]) Scan(iter func(key K, value V) bool)

Scan iterates over all key/values. It's not safe to call or Set or Delete while scanning.

func (*Map[K, V]) Set

func (m *Map[K, V]) Set(key K, value V) (V, bool)

Set assigns a value to a key. Returns the previous value, or false when no value was assigned.

type Set

type Set[K comparable] struct {
	// contains filtered or unexported fields
}

func (*Set[K]) Contains

func (tr *Set[K]) Contains(key K) bool

Get a value for key

func (*Set[K]) Delete

func (tr *Set[K]) Delete(key K)

Delete an item

func (*Set[K]) Insert

func (tr *Set[K]) Insert(key K)

Insert an item

func (*Set[K]) Len

func (tr *Set[K]) Len() int

Len returns the number of items in the tree

func (*Set[K]) Scan

func (tr *Set[K]) Scan(iter func(key K) bool)