collection

package
v1.1.0 Latest Latest
Warning

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

 Go to latest Published: Nov 25, 2024 License: MIT Imports: 3 Imported by: 0

Documentation

Overview

Package collections implements support for generic Collections of data. A collection wraps an underlying Go slice and provides convenience methods and syntatic sugar on top of it.

Index

Constants

This section is empty.

Variables

View Source 
var (
	EmptyCollectionError = &CollectionError{
		code: 100, msg: "invalid operation on an empty collection",
	}
	ValueNotFoundError = &CollectionError{
		code: 101, msg: "value not found",
	}
	IndexOutOfBoundsError = &CollectionError{
		code: 102, msg: "index out of bounds",
	}
)

Functions

func Concatenated added in v1.1.0 

func Concatenated[T any](s1, s2 Collection[T]) iter.Seq[T]

Concatenated returns an iterator that yields the elements of s1 and s2.

example usage: 

a := NewList([]int{1,2})
b := NewList([]int{3,4})
for v := range Concatenated(a, b) {
	fmt.Println(v)
}

output: 

1
2
3
4

func Corresponds 

func Corresponds[T, K any](s1 OrderedCollection[T], s2 OrderedCollection[K], f func(T, K) bool) bool

Corresponds tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate.

example usage: 

c1 := NewSequence([]int{1,2,3,4,5,6})
c2 := NewSequence([]int{2,4,6,8,10,12})
Corresponds(c1, c2, func(i int, j int) bool { return i*2 == j })

output: 

true

func Count 

func Count[T any](s Collection[T], f func(T) bool) int

Count returns the number of elements in the collection that satisfy the predicate function.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
Count(c, func(i int) bool { return i % 2 == 0 })

output: 

3

func Diffed added in v1.1.0 

func Diffed[T comparable](s1 OrderedCollection[T], s2 OrderedCollection[T]) iter.Seq[T]

Diffed returns an iterator that yields the elements of s1 that are not present in s2.

example usage: 

a := NewList([]int{1,2,3,4,5,6})
b := NewList([]int{2,4,6,8,10,12})
for v := range Diffed(a, b) {
	fmt.Println(v)
}

output: 

1
3
5

func DiffedFunc added in v1.1.0 

func DiffedFunc[T any](s1 OrderedCollection[T], s2 OrderedCollection[T], f func(T, T) bool) iter.Seq[T]

DiffedFunc is similar to Diffed but applies to non-comparable types. It takes two collections (s1, s2) and an "equality" function as an argument such as func(a T, b T) bool {return a == b} and returns an iterator that yields the elements of s1 that are not present in s2.

example usage: 

a := NewList([]int{1,2,3,4,5,6})
b := NewList([]int{2,4,6,8,10,12})
for v := range DiffedFunc(a, b, func(a int, b int) bool { return a == b }) {
	fmt.Println(v)
}

output: 

1
3
5

func Distincted added in v1.1.0 

func Distincted[T comparable](s Collection[T]) iter.Seq[T]

Distincted returns an iterator that yields the unique elements of s.

example usage: 

a := NewList([]int{1,1,1,2,2,3})
for v := range Distincted(a) {
	fmt.Println(v)
}

output: 

1
2
3

func DistinctedFunc added in v1.1.0 

func DistinctedFunc[T any](s Collection[T], f func(T, T) bool) iter.Seq[T]

DistinctedFunc is similar to Distincted but applies to non-comparable types. It takes a collection (s) and an "equality" function as an argument such as func(a T, b T) bool {return a == b} and returns an iterator that yields the unique elements of s.

example usage: 

a := NewList([]int{1,1,1,2,2,3})
for v := range DistinctedFunc(a, func(a int, b int) bool { return a == b }) {
	fmt.Println(v)
}

output: 

1
2
3

func EndsWith added in v1.1.0 

func EndsWith[T comparable](s1 OrderedCollection[T], s2 OrderedCollection[T]) bool

EndsWith checks if the elements of the second collection (s2) match the final elements of the first collection (s1) in reverse order.

Example usage: 

c1 := NewSequence([]int{1, 2, 3, 4, 5})
c2 := NewSequence([]int{4, 5})
EndsWith(c1, c2)

Output: 

true

func Filtered added in v1.1.0 

func Filtered[T any](s Collection[T], f func(T) bool) iter.Seq[T]

Filtered returns an iterator that yields the elements of s that satisfy the predicate function f.

example usage: 

a := NewList([]int{1,2,3,4,5,6})
for v := range Filtered(a, func(i int) bool { return i % 2 == 0 }) {
	fmt.Println(v)
}

output: 

2
4
6

func Find 

func Find[T any](s OrderedCollection[T], f func(T) bool) (index int, value T)

Find returns the index and value of the first element that satisfies a predicate, otherwise returns -1 and the zero value.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
Find(c, func(i int) bool {
  return (i + 3) > 5
})

output 

2, 3

func FindLast 

func FindLast[T any](s OrderedCollection[T], f func(T) bool) (index int, value T)

FindLast returns the index and value of the last element that satisfies a predicate, otherwise returns -1 and the zero value.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
FindLast(c, func(i int) bool { return i < 6 })

output: 

4, 5

func ForAll 

func ForAll[T any](s Collection[T], f func(T) bool) bool

ForAll tests whether a predicate holds for all elements of this sequence.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
ForAll(c, func(i int) bool { return i < 10 })

output: 

true

func GroupBy 

func GroupBy[T any, K comparable](s Collection[T], f func(T) K) map[K]Collection[T]

GroupBy takes a collection and a grouping function as input and returns a map where the key is the result of the grouping function and the value is a collection of elements that satisfy the predicate.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
GroupBy(c, func(i int) int { return i % 2 })

output: 

{0:[2,4,6], 1:[1,3,5]}

func Head[T any](s OrderedCollection[T]) (T, error)

Head returns the first element in a Sequence and a nil error. If the sequence is empty, it returns the zero value and an error.

example usage: 

c := NewSequence([]string{"A","B","C"})
c.Head()

output: 

"A", nil

func Intersected added in v1.1.0 

func Intersected[T comparable](s1 Collection[T], s2 Collection[T]) iter.Seq[T]

Intersected returns an iterator that yields the elements of s1 that are also present in s2.

example usage: 

a := NewList([]int{1,3,4,5,6})
b := NewList([]int{2,4,6,8,10,12})
for v := range Intersected(a, b) {
	fmt.Println(v)
}

output: 

4
6

func IntersectedFunc added in v1.1.0 

func IntersectedFunc[T any](s1 Collection[T], s2 Collection[T], f func(T, T) bool) iter.Seq[T]

IntersectedFunc is similar to Intersected but applies to non-comparable types. It takes two collections (s1, s2) and an "equality" function as an argument such as func(a T, b T) bool {return a == b} and returns an iterator that yields the elements of s1 that are also present in s2.

example usage: 

a := NewList([]int{1,3,4,5,6})
b := NewList([]int{2,4,6,8,10,12})
for v := range IntersectedFunc(a, b, func(a int, b int) bool { return a == b }) {
	fmt.Println(v)
}

output: 

4
6

func Last 

func Last[T any](s OrderedCollection[T]) (T, error)

Last returns the last element in the Sequence and a nil error. If the sequence is empty, it returns the zero value and an error.

example usage: 

c := NewSequence([]string{"A","B","C"})
c.Last()

output: 

"C", nil

func Map 

func Map[T, K any](s Collection[T], f func(T) K) []K

Map takes a collection of type T and a mapping function func(T) K, applies the mapping function to each element and returns a slice of type K.

example usage: 

names := NewCollection([]string{"Alice", "Bob", "Charlie"})
Map(names, func(name string) int {
  return len(name)
})

output: 

[5,3,6]

func Mapped added in v1.1.0 

func Mapped[T, K any](s Collection[T], f func(T) K) iter.Seq[K]

Mapped returns an iterator that yields the elements of s transformed by the function f.

example usage: 

a := NewList([]int{1,2,3})
for v := range Mapped(a, func(i int) int { return i * 2 }) {
	fmt.Println(v)
}

output: 

2
4
6

func MaxBy 

func MaxBy[T any, K cmp.Ordered](s Collection[T], f func(T) K) (T, error)

MaxBy returns the element in the collection that has the maximum value according to a comparison function.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
MaxBy(c, func(a int, b int) int { return a - b })

output: 

6

func MinBy 

func MinBy[T any, K cmp.Ordered](s Collection[T], f func(T) K) (T, error)

MinBy returns the element in the collection that has the minimum value according to a comparison function.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
MinBy(c, func(a int, b int) int { return a - b })

output: 

1

func Partition 

func Partition[T any](s Collection[T], f func(T) bool) (Collection[T], Collection[T])

Partition takes a partitioning function as input and returns two collections, the first one contains the elements that match the partitioning condition, the second one contains the rest of the elements.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
Partition(c, func(i int) bool {
  return i%2==0
})

output: 

[2,4,6], [1,3,5]

func Reduce 

func Reduce[T, K any](s Collection[T], f func(K, T) K, init K) K

Reduce takes a collection of type T, a reducing function func(K, T) K, and an initial value of type K as parameters. It applies the reducing function to each element and returns the resulting value K.

example usage: 

numbers := NewCollection([]int{1,2,3,4,5,6})

Reduce(numbers, func(accumulator int, number int) int {
  return accumulator + number
}, 0)

output: 

21

func ReduceRight 

func ReduceRight[T, K any](s OrderedCollection[T], f func(K, T) K, init K) K

ReduceRight takes a collection of type T, a reducing function func(K, T) K, and an initial value of type K as parameters. It applies the reducing function to each element in reverse order and returns the resulting value K.

example usage: 

c := NewSequence([]string{"A","B","C"})
ReduceRight(c, func(acc string, i string) string { return acc + i }, "")

output: 

"CBA"

func Rejected added in v1.1.0 

func Rejected[T any](s Collection[T], f func(T) bool) iter.Seq[T]

Rejected returns an iterator that yields the elements of s that do not satisfy the predicate function f.

example usage: 

a := NewList([]int{1,2,3,4,5,6})
for v := range Rejected(a, func(i int) bool { return i % 2 == 0 }) {
	fmt.Println(v)
}

output: 

1
3
5

func SplitAt 

func SplitAt[T any](s OrderedCollection[T], n int) (OrderedCollection[T], OrderedCollection[T])

SplitAt returns two new sequences containing the first n elements and the rest of the elements.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
SplitAt(c, 3)

output: 

[1,2,3], [4,5,6]

func StartsWith added in v1.1.0 

func StartsWith[T comparable](s1 OrderedCollection[T], s2 OrderedCollection[T]) bool

StartsWith checks if the elements of the second collection (s2) match the initial elements of the first collection (s1) in order.

Example usage: 

c1 := NewSequence([]int{1, 2, 3, 4, 5})
c2 := NewSequence([]int{1, 2})
StartsWith(c1, c2)

Output: 

true

Types

type Collection 

type Collection[T any] interface {
	Add(T)
	Length() int
	New(s ...[]T) Collection[T]
	Random() T
	Values() iter.Seq[T]
}

Collection is a generic interface that must be implemented by all collection sub-types. At a minimum, collections must support the methods defined below.

func Diff 

func Diff[T comparable](s1 Collection[T], s2 Collection[T]) Collection[T]

Diff returns a new collection containing elements that are present in the first collection but not in the second.

example usage: 

c1 := NewSequence([]int{1,2,3,4,5,6})
c2 := NewSequence([]int{2,4,6,8,10,12})
Diff(c1, c2)

output: 

[1,3,5]

func DiffFunc added in v1.1.0 

func DiffFunc[T any](s1 Collection[T], s2 Collection[T], f func(T, T) bool) Collection[T]

DiffFunc is similar to Diff but applies to non-comparable types. It takes two collections (s1, s2) and an "equality" function as an argument such as func(a T, b T) bool {return a == b} and returns a new sequence containing all the elements of s1 that are not present in s2.

example usage: 

c1 := NewSequence([]int{1,2,3,4,5,6})
c2 := NewSequence([]int{2,4,6,8,10,12})
DiffFunc(c1, c2, func(a int, b int) bool { return a == b })

output: 

[1,3,5]

func Distinct 

func Distinct[T any](s Collection[T], f func(T, T) bool) Collection[T]

Distinct returns a new collection containing only the unique elements of the collection.

example usage: 

c := NewSequence([]int{1,1,1,4,5,1,2,2})
Distinct(c, func(i int, i2 int) bool { return i == i2 })

output: 

[1,4,5,2]

func Filter 

func Filter[T any](s Collection[T], f func(T) bool) Collection[T]

Filter returns a new collection containing only the elements that satisfy the predicate function.

example usage: 

numbers := NewSequence([]int{1,2,3,4,5,6})
Filter(numbers, func(t int) bool { return t % 2 == 0 })

output: 

[2,4,6]

func FilterNot 

func FilterNot[T any](s Collection[T], f func(T) bool) Collection[T]

FilterNot returns the complement of the Filter function.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
FilterNot(c, func(t int) bool { return t % 2 == 0 })

output: 

[1,3,5]

func Intersect 

func Intersect[T comparable](s1 Collection[T], s2 Collection[T]) Collection[T]

Intersect returns a new collection containing elements that are present in both input collections.

example usage: 

c1 := NewSequence([]int{1,2,3,4,5,6})
c2 := NewSequence([]int{2,4,6,8,10,12})
Intersect(c1, c2)

output: 

[2,4,6]

func IntersectFunc added in v1.1.0 

func IntersectFunc[T any](s1 Collection[T], s2 Collection[T], f func(T, T) bool) Collection[T]

IntersectFunc is similar to Intersect but applies to non-comparable types. It takes two collections (s1, s2) and an "equality" function as an argument such as func(a T, b T) bool {return a == b} and returns a new sequence containing all the elements of s1 that are also present in s2.

example usage: 

c1 := NewSequence([]int{1,2,3,4,5,6})
c2 := NewSequence([]int{2,4,6,8,10,12})
IntersectFunc(c1, c2, func(a int, b int) bool { return a == b })

output: 

[2,4,6]

type CollectionError 

type CollectionError struct {
	// contains filtered or unexported fields
}

func (*CollectionError) Error 

func (e *CollectionError) Error() string

type OrderedCollection 

type OrderedCollection[T any] interface {
	Collection[T]
	At(index int) T
	All() iter.Seq2[int, T]
	Backward() iter.Seq2[int, T]
	Slice(start, end int) OrderedCollection[T]
	NewOrdered(s ...[]T) OrderedCollection[T]
}

OrderedCollection is a generic interface for collections who's underlying data structure is index-based, and the order of elements matters.

func Drop 

func Drop[T any](s OrderedCollection[T], n int) OrderedCollection[T]

Drop returns a new sequence with the first n elements removed.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.Drop(2)

output: 

[3,4,5,6]

func DropRight 

func DropRight[T any](s OrderedCollection[T], n int) OrderedCollection[T]

DropRight returns a sequence with the last n elements removed.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.DropRight(2)

output: 

[1,2,3,4]

func DropWhile 

func DropWhile[T any](s OrderedCollection[T], f func(T) bool) OrderedCollection[T]

DropWhile returns a sequence with the first n elements that satisfy a predicate removed.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.DropWhile(func(i int) bool { return i < 4 })

output: 

[4,5,6]

func Init 

func Init[T any](s OrderedCollection[T]) OrderedCollection[T]

Init returns a collection containing all elements excluding the last one.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.Init()

output: 

[1,2,3,4,5]

func Reverse 

func Reverse[T any](s OrderedCollection[T]) OrderedCollection[T]

Reverse returns a new sequence with all elements in reverse order.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.Reverse()

output: 

[6,5,4,3,2,1]

func ReverseMap 

func ReverseMap[T, K any](s OrderedCollection[T], f func(T) K) OrderedCollection[K]

ReverseMap takes a collection of type T and a mapping function func(T) K, applies the mapping function to each element in reverseand returns a collection of type K.

example usage: 

names := NewCollection([]string{"Alice", "Bob", "Charlie"})
Map(names, func(name string) int {
  return len(name)
})

output: 

[6, 3, 5]

func Tail 

func Tail[T any](s OrderedCollection[T]) OrderedCollection[T]

Tail returns a new sequence containing all elements excluding the first one.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.Tail()

output: 

[2,3,4,5,6]

func Take 

func Take[T any](s OrderedCollection[T], n int) OrderedCollection[T]

Take returns a new sequence containing the first n elements.

example usage: 

[c := NewSequence([]int{1,2,3,4,5,6})
c.Take(3)

output: 

[1,2,3]

func TakeRight 

func TakeRight[T any](s OrderedCollection[T], n int) OrderedCollection[T]

TakeRight returns a new sequence containing the last n elements.

example usage: 

c := NewSequence([]int{1,2,3,4,5,6})
c.TakeRight(3)

output: 

[4,5,6]

Source Files

View all Source files

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.