This is go-generics, a collection of typesafe generic utilities for slices, sets, and goroutine patterns in Go.
This is version 4 of this library, for the release of Go 1.23.
Earlier versions of this library included a package,
iter
,
that defined an iterator type over several types of containers,
and functions for operating with iterators.
However, Go 1.23 defines its own, better iterator mechanism
via the new “range over function” language feature,
plus a new standard-library package also called iter
.
This version of the go-generics library therefore does away with its iter
package.
The handy functions that iter
contained for working with iterators
(Filter
, Map
, FirstN
, and many more)
can now be found in the github.com/bobg/seqs library,
adapted for Go 1.23 iterators.
(This version of go-generics might have kept iter
as a drop-in replacement for the standard-library package,
but was unable because the standard library defines two types,
iter.Seq[K]
and iter.Seq2[K, V]
,
that go-generics would have had to reference using type aliases;
but Go type aliases do not yet permit type parameters.)
Earlier versions of this library included combinatorial operations in the slices
package.
Those have now been moved to their own library,
github.com/bobg/combo.
Earlier versions of this library included a maps
package,
which was a drop-in replacement for the stdlib maps
(added in Go 1.21)
plus a few convenience functions.
With the advent of Go 1.23 iterators,
those few convenience functions are mostly redundant
(and a couple of them − Keys
and Values
− conflict with new functions in the standard library),
so maps
has been removed.
Earlier versions of this library included a Find
method on the set.Of[T]
type,
for finding some element in the set that satisfies a given predicate.
This method has been removed in favor of composing operations with functions from github.com/bobg/seqs.
For example, s.Find(pred)
can now be written as seqs.First(seqs.Filter(s.All(), pred))
.
The slices
package is useful in three ways:
- It encapsulates hard-to-remember Go idioms for inserting and removing elements to and from the middle of a slice;
- It adds the ability to index from the right end of a slice using negative integers (for example, Get(s, -1) is the same as s[len(s)-1]); and
- It includes
Map
,Filter
, and a few other such functions for processing slice elements with callbacks.
The slices
package is a drop-in replacement
for the slices
package
added to the Go stdlib
in Go 1.21.
There is one difference:
this version of slices
allows the index value passed to Insert
, Delete
, and Replace
to be negative for counting backward from the end of the slice.
The set
package implements the usual collection of functions for sets:
Intersect
, Union
, Diff
, etc.,
as well as member functions for adding and removing items,
checking for the presence of items,
and iterating over items.
The parallel
package contains functions for coordinating parallel workers:
Consumers
manages a set of N workers consuming a stream of values produced by the caller.Producers
manages a set of N workers producing a stream of values consumed by the caller.Values
concurrently produces a set of N values.Pool
manages access to a pool of concurrent workers.Protect
manages concurrent access to a protected data value.