a thread-safe concurrent map for go, support using `interface{}` as key and auto scale up shards

# cmap [![Build Status](https://travis-ci.org/lrita/cmap.svg?branch=master)](https://travis-ci.org/lrita/cmap) [![GoDoc](https://godoc.org/github.com/lrita/cmap?status.png)](https://godoc.org/github.com/lrita/cmap) [![codecov](https://codecov.io/gh/lrita/cmap/branch/master/graph/badge.svg)](https://codecov.io/gh/lrita/cmap) [![Go Report Card](https://goreportcard.com/badge/github.com/lrita/cmap)](https://goreportcard.com/report/github.com/lrita/cmap)

The `map` type in Go doesn't support concurrent reads and writes. `cmap(concurrent-map)` provides a high-performance solution to this by sharding the map with minimal time spent waiting for locks.

The `sync.Map` has a few key differences from this map. The stdlib `sync.Map` is designed for append-only scenarios. So if you want to use the map for something more like in-memory db, you might benefit from using our version. You can read more about it in the golang repo, for example [here](https://github.com/golang/go/issues/21035) and [here](https://stackoverflow.com/questions/11063473/map-with-concurrent-access)

_Here we fork some README document from [concurrent-map](https://github.com/orcaman/concurrent-map)_

## usage

Import the package:

```go
import (
	"github.com/lrita/cmap"
)

```

```bash
go get "github.com/lrita/cmap"
```

The package is now imported under the "cmap" namespace.

## example

```go

	// Create a new map.
	var m cmap.Cmap

	// Stores item within map, sets "bar" under key "foo"
	m.Store("foo", "bar")

	// Retrieve item from map.
	if tmp, ok := m.Load("foo"); ok {
		bar := tmp.(string)
	}

	// Deletes item under key "foo"
	m.Delete("foo")

	// If you are using g1.18+, you can use the generics implementation

	var n cmap.Map[string, string]

	// Stores item within map, sets "bar" under key "foo"
	n.Store("foo", "bar")

	// Retrieve item from map.
	if tmp, ok := n.Load("foo"); ok {
	    bar := tmp
	}

	// Deletes item under key "foo"
	n.Delete("foo")
```

## benchmark

```bash
goos: darwin
goarch: amd64
pkg: github.com/lrita/cmap
BenchmarkLoadMostlyHits/*cmap_test.DeepCopyMap-4         	50000000	        34.5 ns/op
BenchmarkLoadMostlyHits/*cmap_test.RWMutexMap-4          	20000000	        65.2 ns/op
BenchmarkLoadMostlyHits/*sync.Map-4                      	50000000	        34.8 ns/op
BenchmarkLoadMostlyHits/*cmap.Cmap-4                     	30000000	        53.5 ns/op
BenchmarkLoadMostlyMisses/*cmap_test.DeepCopyMap-4       	50000000	        26.7 ns/op
BenchmarkLoadMostlyMisses/*cmap_test.RWMutexMap-4        	20000000	        62.5 ns/op
BenchmarkLoadMostlyMisses/*sync.Map-4                    	50000000	        22.7 ns/op
BenchmarkLoadMostlyMisses/*cmap.Cmap-4                   	30000000	        40.3 ns/op
--- SKIP: BenchmarkLoadOrStoreBalanced/*cmap_test.DeepCopyMap
    cmap_bench_test.go:91: DeepCopyMap has quadratic running time.
BenchmarkLoadOrStoreBalanced/*cmap_test.RWMutexMap-4     	 3000000	       437 ns/op
BenchmarkLoadOrStoreBalanced/*sync.Map-4                 	 3000000	       546 ns/op
BenchmarkLoadOrStoreBalanced/*cmap.Cmap-4                	 3000000	       497 ns/op
--- SKIP: BenchmarkLoadOrStoreUnique/*cmap_test.DeepCopyMap
    cmap_bench_test.go:123: DeepCopyMap has quadratic running time.
BenchmarkLoadOrStoreUnique/*cmap_test.RWMutexMap-4       	 2000000	       990 ns/op
BenchmarkLoadOrStoreUnique/*sync.Map-4                   	 1000000	      1032 ns/op
BenchmarkLoadOrStoreUnique/*cmap.Cmap-4                  	 2000000	       892 ns/op
BenchmarkLoadOrStoreCollision/*cmap_test.DeepCopyMap-4   	100000000	        18.2 ns/op
BenchmarkLoadOrStoreCollision/*cmap_test.RWMutexMap-4    	10000000	       165 ns/op
BenchmarkLoadOrStoreCollision/*sync.Map-4                	100000000	        19.6 ns/op
BenchmarkLoadOrStoreCollision/*cmap.Cmap-4               	20000000	        65.7 ns/op
BenchmarkRange/*cmap_test.DeepCopyMap-4                  	  200000	      8646 ns/op
BenchmarkRange/*cmap_test.RWMutexMap-4                   	   20000	     62046 ns/op
BenchmarkRange/*sync.Map-4                               	  200000	      9317 ns/op
BenchmarkRange/*cmap.Cmap-4                              	   50000	     31107 ns/op
BenchmarkAdversarialAlloc/*cmap_test.DeepCopyMap-4       	 2000000	       531 ns/op
BenchmarkAdversarialAlloc/*cmap_test.RWMutexMap-4        	20000000	        74.3 ns/op
BenchmarkAdversarialAlloc/*sync.Map-4                    	 5000000	       390 ns/op
BenchmarkAdversarialAlloc/*cmap.Cmap-4                   	30000000	        53.6 ns/op
BenchmarkAdversarialDelete/*cmap_test.DeepCopyMap-4      	 5000000	       273 ns/op
BenchmarkAdversarialDelete/*cmap_test.RWMutexMap-4       	20000000	        94.4 ns/op
BenchmarkAdversarialDelete/*sync.Map-4                   	10000000	       137 ns/op
BenchmarkAdversarialDelete/*cmap.Cmap-4                  	30000000	        43.3 ns/op
```


cmap

# Dict
[![GoDoc](https://godoc.org/github.com/srfrog/dict?status.svg)](https://godoc.org/github.com/srfrog/dict)
[![Go Report Card](https://goreportcard.com/badge/github.com/srfrog/dict?svg=1)](https://goreportcard.com/report/github.com/srfrog/dict)
[![Coverage Status](https://coveralls.io/repos/github/srfrog/dict/badge.svg?branch=master)](https://coveralls.io/github/srfrog/dict?branch=master)
![Build Status](https://github.com/srfrog/dict/actions/workflows/go.yml/badge.svg?branch=master)

*Python dictionary data type (dict) in Go*

Package dict is a Go implementation of Python [dict][1], which are hashable object maps.
Dictionaries complement Go map and slice types to provide a simple interface to
store and access key-value data with relatively fast performance at the cost of extra
memory. This is done by using the features of both maps and slices.

## Quick Start

Install using "go get":

	go get github.com/srfrog/dict

Then import from your source:

	import "github.com/srfrog/dict"

View [example_test.go][2] for an extended example of basic usage and features.

## Features

- [x] Initialize a new dict with scalars, slices, maps, channels and other dictionaries.
- [x] Go types int, uint, float, string and fmt.Stringer are hashable for dict keys.
- [x] Go map keys are used for dict keys if they are hashable.
- [x] Dict items are sorted in their insertion order, unlike Go maps.
- [x] Go routine safe with minimal mutex locking (WIP)
- [x] Builtin JSON support for marshalling and unmarshalling
- [ ] sql.Scanner support via optional sub-package (WIP)
- [x] Plenty of tests and examples to get you started quickly

## Documentation

The full code documentation is located at GoDoc:

[http://godoc.org/github.com/srfrog/dict](http://godoc.org/github.com/srfrog/dict)

The source code is thoroughly commented, have a look.

## Usage

Minimal example showing basic usage:

```go
package main

import (
	"fmt"

	"github.com/srfrog/dict"
)

type Car struct {
	Model, BrandID string
	Recalls        int
}

func main() {
	// Map of car models, indexed by VIN.
	// Data source: NHTSA.gov
	vins := map[string]*Car{
		"2C3KA43R08H129584": &Car{
			Model:   "2008 CHRYSLER 300",
			BrandID: "ACB9976A-DB5F-4D57-B9A8-9F5C53D87C7C",
			Recalls: 1,
		},
		"1N6AD07U78C416152": &Car{
			Model:   "2008 NISSAN FRONTIER SE-V6 RWD",
			BrandID: "003096EE-C8FC-4C2F-ADEF-406F86C1F70B",
			Recalls: 5,
		},
		"WDDGF8AB8EA940372": &Car{
			Model:   "2014 Mercedes-Benz C300W4",
			BrandID: "57B7B707-4357-4306-9FD6-1EDCA43CF77B",
			Recalls: 4,
		},
	}

	// Create new dict and initialize with vins map.
	d := dict.New(vins)

	// Add a couple more VINs.
	d.Set("1N4AL2AP4BN404580", &Car{
		Model:   "2011 NISSAN ALTIMA 2.5 S CVT",
		BrandID: "003096EE-C8FC-4C2F-ADEF-406F86C1F70B",
		Recalls: 2,
	})
	d.Set("4T1BE46K48U762452", &Car{
		Model:   "2008 TOYOTA Camry",
		BrandID: "C5764FE4-F1E8-46BE-AFC6-A2FC90110387",
		Recalls: 5,
	})

	// Check current total
	fmt.Println("Total VIN Count:", d.Len())

	// Print VINs that have 3 or more recalls
	for item := range d.Items() {
		car, ok := item.Value.(*Car)
		if !ok {
			continue // Not a Car
		}
		if car.Recalls < 3 {
			continue // Not enough recalls
		}
		fmt.Println("---")
		fmt.Println("VIN:", item.Key)
	}
}

```

[1]: https://docs.python.org/3.7/library/stdtypes.html#dict
[2]: https://github.com/srfrog/dict/blob/master/example_test.go


dict

A persistent, map-like object for the Go programming language. Supports multiple embedded key-value stores

# Go-Shelve
[![Go Reference](https://pkg.go.dev/badge/github.com/lucmq/go-shelve/shelve.svg)](https://pkg.go.dev/github.com/lucmq/go-shelve/shelve)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Go Report Card](https://goreportcard.com/badge/github.com/lucmq/go-shelve)](https://goreportcard.com/report/github.com/lucmq/go-shelve)
[![Go Coverage](https://github.com/lucmq/go-shelve/wiki/coverage.svg)](https://raw.githack.com/wiki/lucmq/go-shelve/coverage.html)
[![DeepSource](https://app.deepsource.com/gh/lucmq/go-shelve.svg/?label=active+issues&show_trend=false&token=iZaN7kSfuZGm1KppBKaqMHME)](https://app.deepsource.com/gh/lucmq/go-shelve/)

Go-Shelve is a dependencies-free Go package that provides a persistent, map-like
object called `Shelf`. It lets you store and retrieve Go objects directly, with
the serialization and storage handled automatically by the `Shelf`. Additionally,
you can customize the underlying key-value storage and serialization Codec to
better suit your application's needs.

This project is inspired by the `shelve` module from the Python standard
library and aims to provide a similar set of functionalities.

Check the [driver's directory](./driver/README.md) for additional storage and
Codec options.

## Installation
To use this package in your Go project, you can install it using `go get`:
```bash
go get github.com/lucmq/go-shelve
```

## Usage
Here are some examples of how to use `go-shelve`:

### Basic
The following example illustrates the usage of a `Shelf` with string keys and
values. The `Shelf` type uses generics and can be instantiated with any Go type
as a value and any comparable type for the key.
```go
package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	"github.com/lucmq/go-shelve/shelve"
)

func main() {
	// Note: In a real application be sure to replace the
	// os.TempDir() with a non temporary directory and
	// provide better error treatment. 
	path := filepath.Join(os.TempDir(), "go-shelve")

	// Open the shelf with default options
	shelf, err := shelve.Open[string, string](path)
	if err != nil {
		log.Fatal(err)
	}
	defer shelf.Close()

	// Use the database
	shelf.Put("language", "Go")
	shelf.Put("module", "Go-Shelve")

	// Note: Saved values will be available between restarts
	value, ok, _ := shelf.Get("language")
	fmt.Println(value, ok)
	
	// Output: Go true
}
```

### Custom Database and Codec
By default, a `Shelf` serializes data using the JSON format and stores it using
`sdb` (for "shelve-db"), a simple key-value storage created for this project.

This database should be suitable for a wide range of applications, but the
[driver's directory](./driver/README.md) provides additional options for
configuring a `Shelf` with other databases from the Go ecosystem.

The example below shows how to customize a `Shelf` to use `BoltDB` for storage
together with `MessagePack` for serialization:
```go
package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	bboltd "github.com/lucmq/go-shelve/driver/db/bbolt"
	"github.com/lucmq/go-shelve/driver/encoding/msgpack"
	"github.com/lucmq/go-shelve/shelve"
)

func main() {
	path := filepath.Join(os.TempDir(), "bolt-example")

	db, _ := bboltd.NewDefault(path, []byte("example-bucket"))
	codec := msgpack.NewDefault()

	// Open the shelf with custom options
	shelf, err := shelve.Open[string, string](
		path,
		shelve.WithDatabase(db),
		shelve.WithCodec(codec),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer shelf.Close()

	// Use the database
	shelf.Put("language", "Go")
	shelf.Put("module", "Go-Shelve")

	value, ok, _ := shelf.Get("language")
	fmt.Println(value, ok)

	// Output: Go true
}
```

### Readable files with `diskv` and `JSON`
An interesting use case for `Shelf` is storing data in files that can be read
transparently with the `JSON` format, each named by a semantically meaningful
key. This can be used to save configuration and application data as
human-readable files.

The `diskv` driver in [`driver/db/diskv`](./driver/db/diskv) provides a
database driver that uses a key-value store based on a file-per-record design
that would suit this purpose.

The example below provides a simple illustration of how this could be done to
save data for an imaginary game:
```go
package main

import (
	"fmt"
	"os"
	"path/filepath"

	diskvd "github.com/lucmq/go-shelve/driver/db/diskv"
	"github.com/lucmq/go-shelve/shelve"
)

var StoragePath = filepath.Join(os.TempDir(), "game-test", "db")

type Player struct {
	Name  string
	Level int
	Gold  int
	Items []string
}

type Config struct {
	Difficulty string
}

// NewShelf creates a customized Shelf using Diskv and JSON.
func NewShelf[V any](path string) (*shelve.Shelf[string, V], error) {
	path = filepath.Join(StoragePath, path)
	extension := "json" // Extension of the record files

	db, err := diskvd.NewDefault(path, extension)
	if err != nil {
		return nil, err
	}

	return shelve.Open[string, V](
		path,
		shelve.WithDatabase(db),
		shelve.WithCodec(shelve.JSONCodec()),
	)
}

func main() {
	// Open the shelf with custom options
	players, _ := NewShelf[Player]("players")
	config, _ := NewShelf[Config]("config")

	defer players.Close()
	defer config.Close()

	// Create the game data
	player := Player{
		Name:  "Frodo",
		Level: 14,
		Gold:  9999,
		Items: []string{"Sting", "Lembas"},
	}
	cfg := Config{
		Difficulty: "Hard",
	}

	// Save the data. Serialization and persistence will be
	// handled automatically by the Shelf.
	players.Put(player.Name, player)
	config.Put("config", cfg)

	// The app storage will contain readable JSON files with
	// configuration and game state, that can be retrieved
	// back to a Go type:
	value, ok, _ := players.Get("Frodo")
	fmt.Println(ok, value.Name, value.Items)

	// Output: true Frodo [Sting Lembas]
}
```

# Contributing
Contributions to this package are welcome! If you find any issues or have suggestions
for improvements, please feel free to open an issue or submit a pull request.

In particular, if you are interested in contributing a driver for a key-value storage
or a encoding format, check this [guideline and wishlist](./driver/README.md).

# License
This project is licensed under the MIT License - see the LICENSE file for details.


go-shelve

Go 1.18+ generic map interface for maps; safe maps; ordered maps; ordered, safe maps; etc

[![Go Reference](https://pkg.go.dev/badge/github.com/goradd/maps.svg)](https://pkg.go.dev/github.com/goradd/maps)
![Build Status](https://img.shields.io/github/workflow/status/goradd/maps/Go)
[![Go Report Card](https://goreportcard.com/badge/github.com/goradd/maps)](https://goreportcard.com/report/github.com/goradd/maps)
[![codecov](https://codecov.io/gh/goradd/maps/branch/main/graph/badge.svg?token=LZNNI26H3L)](https://codecov.io/gh/goradd/maps)

# maps
maps is a library using Go generics that offers a standard interface for manipulating 
different kinds of maps. 

Using the same interface, you can create and use a standard Go map, a map
that is safe for concurrency and/or a map that lets you order the keys in the map.

A Set class is included for quickly determining membership in a group.

## Example

```go
package main

import . "github.com/goradd/maps"
import "fmt"

type myMap = Map[string,int] // the equal sign here is critical!
type myStdMap = StdMap[string, int]

func main() {
  m := new(Map[string, int])
  m.Copy(myStdMap{"b":2, "c":3})
  m.Set("a",1)
  sum := 0
  for v := range m.All() {
    sum += v
  }
  fmt.Print(sum)
}

```

By simply changing myMap to a SafeMap, you can make the map safe for concurrent use.
Or, you can change myMap to a SliceMap, or a SafeSliceMap to also be able to iterate
the map in the order it was created, similar to a PHP map.


goradd/maps

A high-performance, thread-safe generic concurrent hash map implementation with Swiss Map

# Concurrent Swiss Map [![GoDoc][doc-img]][doc] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov] [![Go Report Card][go-report-img]][go-report]

**Concurrent Swiss Map** is an open-source Go library that provides a high-performance, thread-safe generic concurrent hash map implementation designed to handle concurrent access efficiently. It's built with a focus on simplicity, speed, and reliability, making it a solid choice for scenarios where concurrent access to a hash map is crucial.

Uses [dolthub/swiss](https://github.com/dolthub/swiss) map implementation under the hood.

## Installation

Supports 1.18+ Go versions because of Go Generics

```
go get github.com/mhmtszr/concurrent-swiss-map
```

## Usage

New functions will be added soon...

```go
package main

import (
	"hash/fnv"

	csmap "github.com/mhmtszr/concurrent-swiss-map"
)

func main() {
	myMap := csmap.New[string, int](
		// set the number of map shards. the default value is 32.
		csmap.WithShardCount[string, int](32),

		// if don't set custom hasher, use the built-in maphash.
		csmap.WithCustomHasher[string, int](func(key string) uint64 {
			hash := fnv.New64a()
			hash.Write([]byte(key))
			return hash.Sum64()
		}),

		// set the total capacity, every shard map has total capacity/shard count capacity. the default value is 0.
		csmap.WithSize[string, int](1000),
	)

	key := "swiss-map"
	myMap.Store(key, 10)

	val, ok := myMap.Load(key)
	println("load val:", val, "exists:", ok)

	deleted := myMap.Delete(key)
	println("deleted:", deleted)

	ok = myMap.Has(key)
	println("has:", ok)

	empty := myMap.IsEmpty()
	println("empty:", empty)

	myMap.SetIfAbsent(key, 11)

	myMap.Range(func(key string, value int) (stop bool) {
		println("range:", key, value)
		return true
	})

	count := myMap.Count()
	println("count:", count)

	// Output:
	// load val: 10 exists: true
	// deleted: true
	// has: false
	// empty: true
	// range: swiss-map 11
	// count: 1
}
```

## Basic Architecture
![img.png](img.png)

## Benchmark Test
Benchmark was made on:
- Apple M1 Max
- 32 GB memory

Benchmark test results can be obtained by running [this file](concurrent_swiss_map_benchmark_test.go) on local computers.

![benchmark.png](benchmark.png)

### Benchmark Results

- Memory usage of the concurrent swiss map is better than other map implementations in all checked test scenarios.
- In high concurrent systems, the concurrent swiss map is faster, but in systems containing few concurrent operations, it works similarly to RWMutexMap.

[doc-img]: https://godoc.org/github.com/mhmtszr/concurrent-swiss-map?status.svg
[doc]: https://godoc.org/github.com/mhmtszr/concurrent-swiss-map
[ci-img]: https://github.com/mhmtszr/concurrent-swiss-map/actions/workflows/build-test.yml/badge.svg
[ci]: https://github.com/mhmtszr/concurrent-swiss-map/actions/workflows/build-test.yml
[cov-img]: https://codecov.io/gh/mhmtszr/concurrent-swiss-map/branch/master/graph/badge.svg
[cov]: https://codecov.io/gh/mhmtszr/concurrent-swiss-map
[go-report-img]: https://goreportcard.com/badge/github.com/mhmtszr/concurrent-swiss-map
[go-report]: https://goreportcard.com/report/github.com/mhmtszr/concurrent-swiss-map

concurrent-swiss-map

HMap is a concurrent and secure, generic support Map implementation designed to provide an easy-to-use API

<div align="center">
</br>

# HMap - Safe For Concurrent Generic Map

| English | [中文](README_zh.md) |
| --- | --- |

HMap is a safe for concurrent generic map implementation in Go that provides a simple and efficient API. It supports generic key-value pairs and includes methods for querying the length of the map as well as clearing the entire map.

</div>

[![Go Report Card](https://goreportcard.com/badge/github.com/lyonnee/hmap)](https://goreportcard.com/report/github.com/lyonnee/hmap)
![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/lyonnee/hmap)
[![codecov](https://codecov.io/gh/lyonnee/hmap/graph/badge.svg?token=FU9T3QWBVJ)](https://codecov.io/gh/lyonnee/hmap)

## Features

- **Generic Support:** Utilizes Go's generic features for flexibility with different types of key-value pairs.
- **Length Querying:** Easily determine the length of the map using the `Len` method.
- **Clear Map:** Clear the entire map using the `Clean` method.

## Go Version

`>= 1.20`

## Quick Start

### Using `Map`

`Map` is a concurrent-safe map implementation based on a mutex.

```go
package main

import (
	"fmt"
	"github.com/lyonnee/hmap"
)

func main() {
	// Create a new Map instance
	myMap := hmap.NewMap[string, int](10)

	// Store key-value pairs
	myMap.Store("key1", 1)
	myMap.Store("key2", 2)

	// Query the length of the map
	length := myMap.Len()
	fmt.Printf("Map Length: %d\n", length)

	// Clear the map
	myMap.Clean()

	// Query the length of the map after cleaning
	length = myMap.Len()
	fmt.Printf("Map Length after Clean: %d\n", length)
}
```

### Using `SyncMap`

`SyncMap` is a concurrent-safe map implementation based on sync.Map.

```go
package main

import (
	"fmt"
	"github.com/lyonnee/hmap"
)

func main() {
	// Create a new SyncMap instance
	mySyncMap := hmap.NewSyncMap[string, int]()

	// Store key-value pairs
	mySyncMap.Store("key1", 1)
	mySyncMap.Store("key2", 2)

	// Query the length of the map
	length := mySyncMap.Len()
	fmt.Printf("SyncMap Length: %d\n", length)

	// Clear the map
	mySyncMap.Clean()

	// Query the length of the map after cleaning
	length = mySyncMap.Len()
	fmt.Printf("SyncMap Length after Clean: %d\n", length)
}
```

## Comparison of `Map` and `SyncMap`
### Map
- Advantages:
	- mplemented using a mutex, simple and intuitive.
	- Suitable for scenarios with low concurrency read/write operations.
- Disadvantages:
	- Performance may be lower than `SyncMap` in high-concurrency write scenarios, as the mutex causes write operations to block.
### SyncMap
- Advantages:
	- Implemented using sync.Map, suitable for high-concurrency scenarios.
	- Write operations do not block read operations, providing better performance.
- Disadvantages:
	- Implementation is more complex and has a larger codebase.
	- Performance may be lower than `Map` in low-concurrency scenarios.

## Methods

### `New() *Map[K, V]`

Creates a new instance of the HMap.

### `Len() int`

Gets the length of the map.

### `Load(key K) (V, bool)`

Loads the value associated with the specified key.

### `Swap(k K, v V) (V, bool)`

Swaps the value associated with the specified key and returns the previous value. If the key does not exist, the length is incremented.

### `Store(k K, v V)`

Stores the key-value pair. If the key already exists, its value is updated.

### `LoadOrStore(k K, v V) (V, bool)`

Loads the value for the specified key. If the key does not exist, the given value is stored, and the length is incremented.

### `Delete(k K)`

Deletes the value associated with the specified key. If the key exists, the length is decremented.

### `LoadAndDelete(k K) (V, bool)`

Loads and deletes the value associated with the specified key. If the key exists, the length is decremented.

### `Range(fn func(k K, v V) bool)`

Iterates over the map, applying a given function to each key-value pair.

### `Clean()`

Clears the entire map.

### `CompareAndSwap(key K, old, new V) bool`

Compares and swaps the value associated with the specified key. Returns `true` if the swap is successful.

### `CompareAndDelete(key K, old V) bool`

Compares and deletes the value associated with the specified key, given the old value. Returns `true` if the delete is successful. If successful, the length is decremented.

## License

This project is distributed under the [MIT License](LICENSE).

## Contributors

Thanks to all contributors to this project.

## Acknowledgments

Thank you for using HMap! If you have any questions or suggestions, feel free to reach out.


The Best Go Libraries For Data Structures and Algorithms - Maps (6)

cmap

dict

go-shelve

goradd/maps

concurrent-swiss-map

hmap