ordered

package
v0.0.19 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 15, 2025 License: MIT Imports: 12 Imported by: 1

Documentation

Overview

Package ordered provides immutable ordered collection implementations

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Map 

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

Map is a collection implementation that provides elements access by an unique key.

func MapFromSeq2 added in v0.0.15 

func MapFromSeq2[K comparable, V any](seq seq.Seq2[K, V]) Map[K, V]

MapFromSeq2 creates a map with elements retrieved by the seq.

func NewMap 

func NewMap[K comparable, V any](elements ...c.KV[K, V]) Map[K, V]

NewMap instantiates a map using key/value pairs

func NewMapOf 

func NewMapOf[K comparable, V any](order []K, elements map[K]V) Map[K, V]

NewMapOf instantiates Map populated by the 'elements' map key/values

func WrapMap 

func WrapMap[K comparable, V any](order []K, elements map[K]V) Map[K, V]

WrapMap instantiates an ordered Map using a map and an order slice as internal storage.

func (Map[K, V]) All added in v0.0.12 

func (m Map[K, V]) All(consumer func(K, V) bool)

All is used to iterate through the collection using `for key, val := range`.

func (Map[K, V]) Contains 

func (m Map[K, V]) Contains(key K) (ok bool)

Contains checks is the map contains a key

func (Map[K, V]) Conv 

func (m Map[K, V]) Conv(converter func(K, V) (K, V, error)) seq.SeqE[c.KV[K, V]]

Conv returns an errorable seq that applies the 'converter' function to the collection elements

func (Map[K, V]) ConvKey 

func (m Map[K, V]) ConvKey(converter func(K) (K, error)) seq.SeqE[c.KV[K, V]]

ConvKey returns an errorable seq that applies the 'converter' function to keys of the map

func (Map[K, V]) ConvValue 

func (m Map[K, V]) ConvValue(converter func(V) (V, error)) seq.SeqE[c.KV[K, V]]

ConvValue returns an errorable seq that applies the 'converter' function to values of the map

func (Map[K, V]) Convert 

func (m Map[K, V]) Convert(converter func(K, V) (K, V)) seq.Seq2[K, V]

Convert returns a seq that applies the 'converter' function to the collection elements

func (Map[K, V]) ConvertKey 

func (m Map[K, V]) ConvertKey(converter func(K) K) seq.Seq2[K, V]

ConvertKey returns a seq that applies the 'converter' function to keys of the map

func (Map[K, V]) ConvertValue 

func (m Map[K, V]) ConvertValue(converter func(V) V) seq.Seq2[K, V]

ConvertValue returns a seq that applies the 'converter' function to values of the map

func (Map[K, V]) Filt 

func (m Map[K, V]) Filt(filter func(K, V) (bool, error)) seq.SeqE[c.KV[K, V]]

Filt returns an errorable seq consisting of elements that satisfy the condition of the 'filter' function

func (Map[K, V]) FiltKey 

func (m Map[K, V]) FiltKey(filter func(K) (bool, error)) seq.SeqE[c.KV[K, V]]

FiltKey returns an errorable seq consisting of key/value pairs where the key satisfies the condition of the 'filter' function

func (Map[K, V]) FiltValue 

func (m Map[K, V]) FiltValue(filter func(V) (bool, error)) seq.SeqE[c.KV[K, V]]

FiltValue returns an errorable seq consisting of key/value pairs where the value satisfies the condition of the 'filter' function

func (Map[K, V]) Filter 

func (m Map[K, V]) Filter(filter func(K, V) bool) seq.Seq2[K, V]

Filter returns a seq consisting of elements that satisfy the condition of the 'filter' function

func (Map[K, V]) FilterKey 

func (m Map[K, V]) FilterKey(filter func(K) bool) seq.Seq2[K, V]

FilterKey returns a seq consisting of key/value pairs where the key satisfies the condition of the 'filter' function

func (Map[K, V]) FilterValue 

func (m Map[K, V]) FilterValue(filter func(V) bool) seq.Seq2[K, V]

FilterValue returns a seq consisting of key/value pairs where the value satisfies the condition of the 'filter' function

func (Map[K, V]) Get 

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

Get returns the value for a key. If ok==false, then the map does not contain the key.

func (Map[K, V]) HasAny 

func (m Map[K, V]) HasAny(condition func(K, V) bool) bool

HasAny checks whether the map contains a key/va;ue pair that satisfies the condition.

func (Map[K, V]) Head 

func (m Map[K, V]) Head() (K, V, bool)

Head returns the first key\value pair.

func (Map[K, V]) IsEmpty 

func (m Map[K, V]) IsEmpty() bool

IsEmpty returns true if the map is empty

func (Map[K, V]) Keys 

func (m Map[K, V]) Keys() MapKeys[K]

Keys resutrns keys collection

func (Map[K, V]) Len 

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

Len returns amount of elements

func (Map[K, V]) Map 

func (m Map[K, V]) Map() map[K]V

Map collects the key/value pairs into a new map

func (Map[K, V]) Reduce 

func (m Map[K, V]) Reduce(merge func(K, K, V, V) (K, V)) (K, V)

Reduce reduces the key/value pairs of the map into an one pair using the 'merge' function

func (Map[K, V]) Sort 

func (m Map[K, V]) Sort(comparer slice.Comparer[K]) Map[K, V]

Sort returns sorted by keys map

func (Map[K, V]) StableSort 

func (m Map[K, V]) StableSort(comparer slice.Comparer[K]) Map[K, V]

StableSort returns sorted by keys map

func (Map[K, V]) String 

func (m Map[K, V]) String() string

func (Map[K, V]) TrackEach 

func (m Map[K, V]) TrackEach(consumer func(K, V))

TrackEach applies the 'consumer' function for every key/value pairs

func (Map[K, V]) Values 

func (m Map[K, V]) Values() MapValues[K, V]

Values resutrns values collection

type MapKeys 

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

MapKeys is the wrapper for Map'm keys

func WrapKeys 

func WrapKeys[K comparable](elements []K) MapKeys[K]

WrapKeys instantiates MapKeys using the elements as internal storage

func (MapKeys[K]) All added in v0.0.12 

func (m MapKeys[K]) All(consumer func(K) bool)

All is used to iterate through the collection using `for key := range`.

func (MapKeys[K]) Append 

func (m MapKeys[K]) Append(out []K) []K

Append collects the values to the specified 'out' slice

func (MapKeys[K]) Conv 

func (m MapKeys[K]) Conv(converter func(K) (K, error)) seq.SeqE[K]

Conv returns an errorable seq that applies the 'converter' function to the collection elements

func (MapKeys[K]) Convert 

func (m MapKeys[K]) Convert(converter func(K) K) seq.Seq[K]

Convert returns a seq that applies the 'converter' function to the collection elements

func (MapKeys[K]) Filt 

func (m MapKeys[K]) Filt(filter func(K) (bool, error)) seq.SeqE[K]

Filt returns an errorable seq consisting of elements that satisfy the condition of the 'filter' function

func (MapKeys[K]) Filter 

func (m MapKeys[K]) Filter(filter func(K) bool) seq.Seq[K]

Filter returns a seq consisting of elements that satisfy the condition of the 'filter' function

func (MapKeys[K]) First 

func (m MapKeys[K]) First(condition func(K) bool) (K, bool)

First returns the first key that satisfies requirements of the condition

func (MapKeys[K]) ForEach 

func (m MapKeys[K]) ForEach(consumer func(K))

ForEach applies the 'consumer' function for every element

func (MapKeys[K]) Get 

func (m MapKeys[K]) Get(index int) (K, bool)

Get returns an element by the index, otherwise, if the provided index is ouf of the collection len, returns zero T and false in the second result

func (MapKeys[K]) HasAny 

func (m MapKeys[K]) HasAny(condition func(K) bool) bool

HasAny checks whether the collection contains a key that satisfies the condition.

func (MapKeys[K]) Head 

func (m MapKeys[K]) Head() (K, bool)

Head returns the first element.

func (MapKeys[K]) IAll added in v0.0.15 

func (m MapKeys[K]) IAll(consumer func(int, K) bool)

IAll is used to iterate through the collection using `for index, key := range`.

func (MapKeys[K]) IsEmpty 

func (m MapKeys[K]) IsEmpty() bool

IsEmpty returns true if the collection is empty

func (MapKeys[K]) Len 

func (m MapKeys[K]) Len() int

Len returns amount of elements

func (MapKeys[K]) Reduce 

func (m MapKeys[K]) Reduce(merge func(K, K) K) K

Reduce reduces the elements into an one using the 'merge' function

func (MapKeys[K]) Slice 

func (m MapKeys[K]) Slice() (out []K)

Slice collects the elements to a slice

func (MapKeys[K]) String 

func (m MapKeys[K]) String() string

String returns string representation of the collection

type MapValues 

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

MapValues is the wrapper for Map'm values.

func WrapVal 

func WrapVal[K comparable, V any](order []K, elements map[K]V) MapValues[K, V]

WrapVal instantiates MapValues using elements as internal storage.

func (MapValues[K, V]) All added in v0.0.12 

func (m MapValues[K, V]) All(consumer func(V) bool)

All is used to iterate through the collection using `for val := range`.

func (MapValues[K, V]) Append 

func (m MapValues[K, V]) Append(out []V) (values []V)

Append collects the values to the specified 'out' slice

func (MapValues[K, V]) Conv 

func (m MapValues[K, V]) Conv(converter func(V) (V, error)) seq.SeqE[V]

Conv returns an errorable seq that applies the 'converter' function to the collection elements

func (MapValues[K, V]) Convert 

func (m MapValues[K, V]) Convert(converter func(V) V) seq.Seq[V]

Convert returns a seq that applies the 'converter' function to the collection elements

func (MapValues[K, V]) Filt 

func (m MapValues[K, V]) Filt(filter func(V) (bool, error)) seq.SeqE[V]

Filt returns an errorable seq consisting of elements that satisfy the condition of the 'filter' function

func (MapValues[K, V]) Filter 

func (m MapValues[K, V]) Filter(filter func(V) bool) seq.Seq[V]

Filter returns a seq consisting of elements that satisfy the condition of the 'filter' function

func (MapValues[K, V]) First 

func (m MapValues[K, V]) First(condition func(V) bool) (V, bool)

First returns the first key\value pair that satisfies the condition.

func (MapValues[K, V]) ForEach 

func (m MapValues[K, V]) ForEach(consumer func(V))

ForEach applies the 'consumer' function for every value

func (MapValues[K, V]) Get 

func (m MapValues[K, V]) Get(index int) (V, bool)

Get returns an element by the index, otherwise, if the provided index is ouf of the collection len, returns zero T and false in the second result

func (MapValues[K, V]) HasAny 

func (m MapValues[K, V]) HasAny(condition func(V) bool) bool

HasAny checks whether the collection contains a value that satisfies the condition.

func (MapValues[K, V]) Head 

func (m MapValues[K, V]) Head() (V, bool)

Head returns the first element.

func (MapValues[K, V]) IAll added in v0.0.15 

func (m MapValues[K, V]) IAll(consumer func(int, V) bool)

IAll is used to iterate through the collection using `for index, val := range`.

func (MapValues[K, V]) IsEmpty 

func (m MapValues[K, V]) IsEmpty() bool

IsEmpty returns true if the collection is empty

func (MapValues[K, V]) Len 

func (m MapValues[K, V]) Len() int

Len returns amount of elements

func (MapValues[K, V]) Reduce 

func (m MapValues[K, V]) Reduce(merge func(V, V) V) V

Reduce reduces the elements into an one using the 'merge' function

func (MapValues[K, V]) Slice 

func (m MapValues[K, V]) Slice() (values []V)

Slice collects the values to a slice

func (MapValues[K, V]) String 

func (m MapValues[K, V]) String() string

type Set 

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

Set is a collection implementation that provides storage for unique elements, prevents duplication, and guarantees access order. The elements must be comparable.

func NewSet 

func NewSet[T comparable](elements ...T) Set[T]

NewSet instantiates set and copies elements to it

func SetFromSeq added in v0.0.15 

func SetFromSeq[T comparable](seq seq.Seq[T]) Set[T]

SetFromSeq creates a set with elements retrieved by the seq.

func WrapSet 

func WrapSet[T comparable](order []T, elements map[T]struct{}) Set[T]

WrapSet creates a set using a map and an order slice as the internal storage.

func (Set[T]) All added in v0.0.12 

func (s Set[T]) All(consumer func(T) bool)

All is used to iterate through the collection using `for e := range`.

func (Set[T]) Append 

func (s Set[T]) Append(out []T) []T

Append collects the values to the specified 'out' slice

func (Set[T]) Contains 

func (s Set[T]) Contains(element T) (ok bool)

Contains checks is the collection contains an element

func (Set[T]) Conv 

func (s Set[T]) Conv(converter func(T) (T, error)) seq.SeqE[T]

Conv returns an errorable seq that applies the 'converter' function to the collection elements

func (Set[T]) Convert 

func (s Set[T]) Convert(converter func(T) T) seq.Seq[T]

Convert returns a seq that applies the 'converter' function to the collection elements

func (Set[T]) Filt 

func (s Set[T]) Filt(filter func(T) (bool, error)) seq.SeqE[T]

Filt returns an errorable seq consisting of elements that satisfy the condition of the 'filter' function

func (Set[T]) Filter 

func (s Set[T]) Filter(filter func(T) bool) seq.Seq[T]

Filter returns a seq consisting of elements that satisfy the condition of the 'filter' function

func (Set[T]) First 

func (s Set[T]) First(condition func(T) bool) (T, bool)

First returns the first element that satisfies requirements of the condition.

func (Set[T]) ForEach 

func (s Set[T]) ForEach(consumer func(T))

ForEach applies the 'consumer' function for every element

func (Set[T]) HasAny 

func (s Set[T]) HasAny(condition func(T) bool) bool

HasAny checks whether the set contains an element that satisfies the condition.

func (Set[T]) Head 

func (s Set[T]) Head() (T, bool)

Head returns the first element.

func (Set[T]) IAll added in v0.0.15 

func (s Set[T]) IAll(consumer func(int, T) bool)

IAll is used to iterate through the collection using `for i, e := range`.

func (Set[T]) IsEmpty 

func (s Set[T]) IsEmpty() bool

IsEmpty returns true if the collection is empty

func (Set[T]) Len 

func (s Set[T]) Len() int

Len returns amount of elements

func (Set[T]) Reduce 

func (s Set[T]) Reduce(merge func(T, T) T) T

Reduce reduces the elements into an one using the 'merge' function

func (Set[T]) Slice 

func (s Set[T]) Slice() []T

Slice collects the elements to a slice

func (Set[T]) Sort 

func (s Set[T]) Sort(comparer slice.Comparer[T]) Set[T]

Sort sorts the elements

func (Set[T]) StableSort 

func (s Set[T]) StableSort(comparer slice.Comparer[T]) Set[T]

StableSort sorts the elements

func (Set[T]) String 

func (s Set[T]) String() string

func (Set[T]) Tail 

func (s Set[T]) Tail() (T, bool)

Tail returns the latest element.

Source Files

View all Source files

Directories

Path Synopsis
Package map_ provides immutale ordered.Map constructors
 Package map_ provides immutale ordered.Map constructors
Package set provides github.com/m4gshm/gollections/collection/ordered.Set constructors and helpers
 Package set provides github.com/m4gshm/gollections/collection/ordered.Set constructors and helpers

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.