seq2

package
v0.7.0 Latest Latest
Warning

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

 Go to latest Published: Apr 1, 2025 License: MIT Imports: 8 Imported by: 1

Documentation

Overview

Package seq2 provides a comprehensive set of utilities for working with key-value sequences in Go applications.

The goal of this package is to offer a rich set of functions for creating, transforming, and consuming iter.Seq2, enabling developers to work with collections of key-value pairs in a functional programming style. The package includes utilities for filtering, mapping, reducing, and sorting sequences, as well as combining and partitioning them.

The package is designed to reduce boilerplate code and improve readability by providing a consistent API for common sequence operations. It leverages Go's type safety and generics to ensure that operations on sequences are both flexible and safe. The Sequence struct is worth mentioning explicitly, allowing method chaining and fluent composition of sequence operations.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Append 

func Append[K any, V any](seq iter.Seq2[K, V], key K, value V) iter.Seq2[K, V]

Append appends element to the end of a sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2})
	input = seq2.Sort(input)

	// Append a new key-value pair to the sequence
	appended := seq2.Append(input, "c", 3)

	result := seq2.Collect(appended)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func Collect 

func Collect[K comparable, V any](seq iter.Seq2[K, V]) map[K]V

Collect collects the elements of the given sequence into a map.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	result := seq2.Collect(input)

	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func Concat 

func Concat[K any, V any](sequences ...iter.Seq2[K, V]) iter.Seq2[K, V]

Concat concatenates multiple sequences into a single sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	first := seq2.FromMap(map[string]int{"a": 1, "b": 2})
	first = seq2.Sort(first)
	second := seq2.FromMap(map[string]int{"c": 3, "d": 4})
	second = seq2.Sort(second)

	// Concatenate two sequences
	combined := seq2.Concat(first, second)

	result := seq2.Collect(combined)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3 d:4]

func Contains 

func Contains[K comparable, V any](seq iter.Seq2[K, V], key K) bool

Contains returns true if the key is in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	contains := seq2.Contains(input, "b")

	fmt.Println(contains)
}

Output:

true

func ContainsAll 

func ContainsAll[K comparable, V any](seq iter.Seq2[K, V], keys ...K) bool

ContainsAll returns true if all keys are in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	containsAll := seq2.ContainsAll(input, "a", "c", "d")

	fmt.Println(containsAll)
}

Output:

true

func ContainsAllValues 

func ContainsAllValues[K any, V comparable](seq iter.Seq2[K, V], values ...V) bool

ContainsAllValues returns true if all values are in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	containsAllValues := seq2.ContainsAllValues(input, 1, 3)

	fmt.Println(containsAllValues)
}

Output:

true

func ContainsPair 

func ContainsPair[K comparable, V comparable](seq iter.Seq2[K, V], key K, value V) bool

ContainsPair returns true if the key-value pair is in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	containsPair := seq2.ContainsPair(input, "b", 2)

	fmt.Println(containsPair)
}

Output:

true

func ContainsValue 

func ContainsValue[K any, V comparable](seq iter.Seq2[K, V], value V) bool

ContainsValue returns true if the value is in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	containsValue := seq2.ContainsValue(input, 3)

	fmt.Println(containsValue)
}

Output:

true

func Count 

func Count[K any, V any](seq iter.Seq2[K, V]) int

Count returns the number of elements in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Count returns the number of elements in the sequence
	count := seq2.Count(input)

	fmt.Println(count)
}

Output:

3

func Cycle 

func Cycle[K, V any](seq iter.Seq2[K, V], count int) iter.Seq2[K, V]

Cycle repeats the sequence count times.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2})
	input = seq2.Sort(input)

	// Repeat the sequence 2 times
	cycled := seq2.Cycle(input, 2)

	seq2.ForEach(cycled, func(k string, v int) {
		fmt.Println(k, v)
	})

}

Output:

a 1
b 2
a 1
b 2

func Distinct 

func Distinct[K comparable, V comparable](seq iter.Seq2[K, V]) iter.Seq2[K, V]

Distinct returns a new sequence that contains only the unique elements of the given sequence. SQL-like alias for Uniq.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence with duplicate key-value pairs
	input := seq2.Concat(
		seq2.FromMap(map[string]int{"a": 1, "b": 2}),
		seq2.FromMap(map[string]int{"a": 1, "c": 3}),
	)

	// Distinct is an alias for Uniq
	unique := seq2.Distinct(input)

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func DistinctKeys 

func DistinctKeys[K comparable, V any](seq iter.Seq2[K, V]) iter.Seq2[K, V]

DistinctKeys returns a new sequence that contains only the unique keys of the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence with duplicate keys
	input := seq2.Concat(
		seq2.FromMap(map[string]int{"a": 1, "b": 2}),
		seq2.FromMap(map[string]int{"a": 3, "c": 4}),
	)

	// DistinctKeys is an alias for UniqKeys
	unique := seq2.DistinctKeys(input)

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:4]

func Each 

func Each[K any, V any](seq iter.Seq2[K, V], consumer Consumer[K, V]) iter.Seq2[K, V]

Each is an alias for Tap.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	tapped := seq2.Each(input, func(k string, v int) {
		fmt.Printf("Each: %s -> %d\n", k, v)
	})

	seq2.Flush(tapped)

}

Output:

Each: a -> 1
Each: b -> 2
Each: c -> 3

func Empty 

func Empty[K, V any]() iter.Seq2[K, V]

Empty returns an empty sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create an empty sequence
	empty := seq2.Empty[any, any]()

	seq2.ForEach(empty, func(any, any) {
		fmt.Println("Should not be called")
	})
}

func Every 

func Every[K, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) bool

Every returns true if all elements satisfy the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 2, "b": 4, "c": 6, "d": 8})
	input = seq2.Sort(input)

	every := seq2.Every(input, func(k string, v int) bool {
		return v%2 == 0
	})

	fmt.Println(every)
}

Output:

true

func Exists 

func Exists[K, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) bool

Exists returns true if there is at least one element that satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	exists := seq2.Exists(input, func(k string, v int) bool {
		return k > "c" && v > 3
	})

	fmt.Println(exists)
}

Output:

true

func Filter 

func Filter[K any, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

Filter returns a new sequence that contains only the elements that satisfy the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Filter elements where the value is even
	filtered := seq2.Filter(input, func(k string, v int) bool {
		return v%2 == 0
	})

	result := seq2.Collect(filtered)
	fmt.Println(result)
}

Output:

map[b:2 d:4]

func FilterByKey 

func FilterByKey[K any, V any](seq iter.Seq2[K, V], predicate KeyPredicate[K]) iter.Seq2[K, V]

FilterByKey returns a new sequence that contains only the elements that satisfy the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Filter elements by key
	filtered := seq2.FilterByKey(input, func(k string) bool {
		return k > "b"
	})

	result := seq2.Collect(filtered)
	fmt.Println(result)
}

Output:

map[c:3 d:4]

func FilterByValue 

func FilterByValue[K any, V any](seq iter.Seq2[K, V], predicate ValuePredicate[V]) iter.Seq2[K, V]

FilterByValue returns a new sequence that contains only the elements that satisfy the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Filter elements by value
	filtered := seq2.FilterByValue(input, func(v int) bool {
		return v <= 2
	})

	result := seq2.Collect(filtered)
	fmt.Println(result)
}

Output:

map[a:1 b:2]

func Find 

func Find[K, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) (optional.Elem[K], optional.Elem[V])

Find returns the first element that satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	k, v := seq2.Find(input, func(k string, v int) bool {
		return v > 2
	})

	fmt.Printf("Key: %s, Value: %d\n", k.MustGet(), v.MustGet())
}

Output:

Key: c, Value: 3

func FindAll 

func FindAll[K, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

FindAll returns all elements that satisfy the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	found := seq2.FindAll(input, func(k string, v int) bool {
		return v > 2
	})

	result := seq2.Collect(found)
	fmt.Println(result)
}

Output:

map[c:3 d:4]

func FindByKey 

func FindByKey[K, V any](seq iter.Seq2[K, V], predicate KeyPredicate[K]) (optional.Elem[K], optional.Elem[V])

FindByKey returns the first element that satisfies the predicate.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	k, v := seq2.FindByKey(input, func(k string) bool {
		return strings.ToUpper(k) == "B"
	})

	fmt.Printf("Key: %s, Value: %d\n", k.MustGet(), v.MustGet())
}

Output:

Key: b, Value: 2

func FindByValue 

func FindByValue[K, V any](seq iter.Seq2[K, V], predicate ValuePredicate[V]) (optional.Elem[K], optional.Elem[V])

FindByValue returns the first element that satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	k, v := seq2.FindByValue(input, func(v int) bool {
		return v%4 == 0
	})

	fmt.Printf("Key: %s, Value: %d\n", k.MustGet(), v.MustGet())
}

Output:

Key: d, Value: 4

func FindLast 

func FindLast[K, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) (optional.Elem[K], optional.Elem[V])

FindLast returns the last element that satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	k, v := seq2.FindLast(input, func(k string, v int) bool {
		return v > 2
	})

	fmt.Printf("Key: %s, Value: %d\n", k.MustGet(), v.MustGet())
}

Output:

Key: d, Value: 4

func Flush 

func Flush[K any, V any](seq iter.Seq2[K, V])

Flush consumes all elements of the input sequence.

Example 
package main

import (
	"fmt"
	"iter"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence that has side effects when consumed
	sideEffects := iter.Seq2[string, int](func(yield func(string, int) bool) {
		fmt.Println("First element consumed")
		if !yield("a", 1) {
			return
		}
		fmt.Println("Second element consumed")
		if !yield("b", 2) {
			return
		}
		fmt.Println("Third element consumed")
		if !yield("c", 3) {
			return
		}
	})

	// Flush consumes all elements without doing anything with them
	seq2.Flush(sideEffects)

}

Output:

First element consumed
Second element consumed
Third element consumed

func FoldKeys 

func FoldKeys[K any, V any](seq2 iter.Seq2[K, V], accumulator func(agg K, key K, value V) K) optional.Elem[K]

FoldKeys applies a function against an accumulator and each element in the sequence (from left to right) to reduce it to a single value. Notice: first value will be omitted and the first key will be used as initial value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// FoldKeys concatenates all keys starting with the first key
	result := seq2.FoldKeys(input, func(agg string, key string, value int) string {
		return agg + key
	})

	fmt.Println(result.MustGet())
}

Output:

abc

func FoldKeysRight 

func FoldKeysRight[K any, V any](seq2 iter.Seq2[K, V], accumulator func(agg K, key K, value V) K) optional.Elem[K]

FoldKeysRight applies a function against an accumulator and each element in the sequence (from right to left) to reduce it to a single value. Notice: last value will be omitted and the last key will be used as initial value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// FoldKeysRight concatenates all keys starting from the right
	result := seq2.FoldKeysRight(input, func(agg string, key string, value int) string {
		return agg + key
	})

	fmt.Println(result.MustGet())
}

Output:

cba

func FoldValues 

func FoldValues[K any, V any](seq2 iter.Seq2[K, V], accumulator func(agg V, key K, value V) V) optional.Elem[V]

FoldValues applies a function against an accumulator and each element in the sequence (from left to right) to reduce it to a single value. Notice: first key will be omitted and the first value will be used as initial value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// FoldValues to calculate the product of all values
	product := seq2.FoldValues(input, func(agg int, key string, value int) int {
		return agg * value
	})

	fmt.Println(product.MustGet())
}

Output:

6

func FoldValuesRight 

func FoldValuesRight[K any, V any](seq2 iter.Seq2[K, V], accumulator func(agg V, key K, value V) V) optional.Elem[V]

FoldValuesRight applies a function against an accumulator and each element in the sequence (from right to left) to reduce it to a single value. Notice: last key will be omitted and the last value will be used as initial value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 3, "b": 5, "c": 10})
	input = seq2.Sort(input)

	// FoldValuesRight performs right-to-left division
	result := seq2.FoldValuesRight(input, func(agg int, key string, value int) int {
		return agg - value
	})

	fmt.Println(result.MustGet())
}

Output:

2

func ForEach 

func ForEach[K any, V any](seq iter.Seq2[K, V], consumer Consumer[K, V])

ForEach applies consumer to each element of the input sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of("a", "b", "c")

	// ForEach consumes the sequence and applies the function
	seq2.ForEach(input, func(k int, v string) {
		fmt.Printf("%d: %s\n", k, v)
	})

}

Output:

0: a
1: b
2: c

func FromMap 

func FromMap[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V]

FromMap creates a new iter.Seq2 from the given map.

func FromSlice 

func FromSlice[Slice ~[]E, E any](slice Slice) iter.Seq2[int, E]

FromSlice creates a new sequence from the given slice with index as keys.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence from a slice
	slice := []string{"a", "b", "c"}
	sequence := seq2.FromSlice(slice)

	result := seq2.Collect(sequence)
	fmt.Println(result)
}

Output:

map[0:a 1:b 2:c]

func Get 

func Get[K comparable, V any](seq iter.Seq2[K, V], key K) optional.Elem[V]

Get returns the element at the specified key.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	value := seq2.Get(input, "c")

	fmt.Println(value.MustGet())
}

Output:

3

func IsEmpty 

func IsEmpty[K, V any](seq iter.Seq2[K, V]) bool

IsEmpty returns true if the sequence is empty.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	emptySeq := seq2.Empty[any, any]()

	nonEmptySeq := seq2.Of("a")

	fmt.Printf("Empty sequence: %v\n", seq2.IsEmpty(emptySeq))
	fmt.Printf("Non-empty sequence: %v\n", seq2.IsEmpty(nonEmptySeq))
}

Output:

Empty sequence: true
Non-empty sequence: false

func IsNotEmpty 

func IsNotEmpty[K, V any](seq iter.Seq2[K, V]) bool

IsNotEmpty returns true if the sequence is not empty.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	emptySeq := seq2.Empty[any, any]()

	nonEmptySeq := seq2.Of("a")

	fmt.Printf("Empty sequence: %v\n", seq2.IsNotEmpty(emptySeq))
	fmt.Printf("Non-empty sequence: %v\n", seq2.IsNotEmpty(nonEmptySeq))
}

Output:

Empty sequence: false
Non-empty sequence: true

func Keys 

func Keys[K, V any](seq iter.Seq2[K, V]) iter.Seq[K]

Keys returns a sequence of keys from a sequence of key-value pairs.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of("a", "b", "c")

	keys := seq2.Keys(input)

	seq.ForEach(keys, func(k int) {
		fmt.Print(k, " ")
	})
}

Output:

0 1 2

func Limit 

func Limit[K any, V any](seq iter.Seq2[K, V], n int) iter.Seq2[K, V]

Limit returns a new sequence that contains only the first n elements of the given sequence. SQL-like alias for Take.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Limit is an alias for Take
	taken := seq2.Limit(input, 3)

	result := seq2.Collect(taken)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func Map 

func Map[K, V, RV any](seq iter.Seq2[K, V], mapper Mapper[K, V, RV]) iter.Seq2[K, RV]

Map applies a mapper function to each value of the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Map both key and value to produce a new value (keeps original keys)
	mapped := seq2.Map(input, func(k string, v int) string {
		return fmt.Sprintf("Value of %s is %d", k, v)
	})

	result := seq2.Collect(mapped)
	fmt.Println(result)
}

Output:

map[a:Value of a is 1 b:Value of b is 2 c:Value of c is 3]

func MapKeys 

func MapKeys[K, V, RK any](seq iter.Seq2[K, V], mapper KeyMapper[K, RK]) iter.Seq2[RK, V]

MapKeys applies a mapper function to each key of the sequence.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Map keys to uppercase (keeps original values)
	mapped := seq2.MapKeys(input, func(k string) string {
		return strings.ToUpper(k)
	})

	result := seq2.Collect(mapped)
	fmt.Println(result)
}

Output:

map[A:1 B:2 C:3]

func MapPairs 

func MapPairs[K, V, RK, RV any](seq iter.Seq2[K, V], mapper DoubleMapper[K, V, RK, RV]) iter.Seq2[RK, RV]

MapPairs applies a mapper function to each element of the sequence.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Map keys to uppercase and multiply values by 10
	mapped := seq2.MapPairs(input, func(k string, v int) (string, int) {
		return strings.ToUpper(k), v * 10
	})

	result := seq2.Collect(mapped)
	fmt.Println(result)
}

Output:

map[A:10 B:20 C:30]

func MapTo 

func MapTo[K, V, RV any](seq iter.Seq2[K, V], mapper Mapper[K, V, RV]) iter.Seq[RV]

MapTo applies a mapper function to each element of the sequence and returns a sequence of mapper results.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Map each key-value pair to a string
	mapped := seq2.MapTo(input, func(k string, v int) string {
		return fmt.Sprintf("%s=%d", k, v)
	})

	seq.ForEach(mapped, func(v string) {
		fmt.Println(v)
	})
}

Output:

a=1
b=2
c=3

func MapToValues 

func MapToValues[K, V, RV any](seq iter.Seq2[K, V], mapper ValueMapper[V, RV]) iter.Seq[RV]

MapToValues applies a mapper function to each value of the sequence and returns a sequence of values only.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of("a", "b", "c")

	// Map values to strings and return as sequence of values
	mapped := seq2.MapToValues(input, func(v string) string {
		return fmt.Sprintf("Value: %s", v)
	})

	for v := range mapped {
		fmt.Println(v)
	}

}

Output:

Value: a
Value: b
Value: c

func MapValues 

func MapValues[K, V, RV any](seq iter.Seq2[K, V], mapper ValueMapper[V, RV]) iter.Seq2[K, RV]

MapValues applies a mapper function to each value of the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Map values to their squares (keeps original keys)
	mapped := seq2.MapValues(input, func(v int) int {
		return v * v
	})

	result := seq2.Collect(mapped)
	fmt.Println(result)
}

Output:

map[a:1 b:4 c:9]

func MaxKey 

func MaxKey[K types.Ordered, V any](seq2 iter.Seq2[K, V]) optional.Elem[K]

MaxKey returns the maximum key in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 5, "z": 10, "c": 3})
	input = seq2.Sort(input)

	// Find the maximum key (lexicographically)
	maxK := seq2.MaxKey(input)

	fmt.Println(maxK.MustGet())
}

Output:

z

func MaxValue 

func MaxValue[K any, V types.Ordered](seq2 iter.Seq2[K, V]) optional.Elem[V]

MaxValue returns the maximum value in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 5, "b": 10, "c": 3})
	input = seq2.Sort(input)

	// Find the maximum value
	maxV := seq2.MaxValue(input)

	fmt.Println(maxV.MustGet())
}

Output:

10

func MinKey 

func MinKey[K types.Ordered, V any](seq2 iter.Seq2[K, V]) optional.Elem[K]

MinKey returns the minimum key in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 5, "z": 10, "c": 3})
	input = seq2.Sort(input)

	// Find the minimum key (lexicographically)
	minK := seq2.MinKey(input)

	fmt.Println(minK.MustGet())
}

Output:

a

func MinValue 

func MinValue[K any, V types.Ordered](seq2 iter.Seq2[K, V]) optional.Elem[V]

MinValue returns the minimum value in the .

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 5, "b": 10, "c": 3})
	input = seq2.Sort(input)

	// Find the minimum value
	minV := seq2.MinValue(input)

	fmt.Println(minV.MustGet())
}

Output:

3

func Narrow 

func Narrow[K, V, RV any](seq iter.Seq2[K, V], mapper Mapper[K, V, RV]) iter.Seq[RV]

Narrow applies a mapper function to each element of the sequence and returns a sequence of mapper results. Alias for MapTo

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Narrow is an alias for MapTo
	mapped := seq2.Narrow(input, func(k string, v int) string {
		return fmt.Sprintf("%s=%d", k, v)
	})

	seq.ForEach(mapped, func(v string) {
		fmt.Println(v)
	})
}

Output:

a=1
b=2
c=3

func None 

func None[K, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) bool

None returns true if no element satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	none := seq2.None(input, func(k string, v int) bool {
		return v > 10
	})

	fmt.Println(none)
}

Output:

true

func NotContains 

func NotContains[K comparable, V any](seq iter.Seq2[K, V], key K) bool

NotContains returns true if the key is not in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	notContains := seq2.NotContains(input, "x")

	fmt.Println(notContains)
}

Output:

true

func NotContainsPair 

func NotContainsPair[K comparable, V comparable](seq iter.Seq2[K, V], key K, value V) bool

NotContainsPair returns true if the key-value pair is not in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	notContainsPair := seq2.NotContainsPair(input, "b", 3)

	fmt.Println(notContainsPair)
}

Output:

true

func NotContainsValue 

func NotContainsValue[K any, V comparable](seq iter.Seq2[K, V], value V) bool

NotContainsValue returns true if the value is not in the sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	notContainsValue := seq2.NotContainsValue(input, 5)

	fmt.Println(notContainsValue)
}

Output:

true

func Of 

func Of[E any](elems ...E) iter.Seq2[int, E]

Of creates a new indexed sequence from the given elements.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence from individual elements
	indexed := seq2.Of(1, 2, 3)

	result := seq2.Collect(indexed)
	fmt.Println(result)
}

Output:

map[0:1 1:2 2:3]

func Offset 

func Offset[K any, V any](seq iter.Seq2[K, V], n int) iter.Seq2[K, V]

Offset returns a new sequence that skips the first n elements of the given sequence. SQL-like alias for Skip.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of(10, 20, 30, 40, 20)

	// Skip the first 2 elements
	skipped := seq2.Offset(input, 2)

	result := seq2.Collect(skipped)
	fmt.Println(result)
}

Output:

map[2:30 3:40 4:20]

func Pair 

func Pair[K, V any](k K, v V) iter.Seq2[K, V]

Pair returns a sequence with given key value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence with a single key-value pair
	single := seq2.Pair("key", 42)

	seq2.ForEach(single, func(k string, v int) {
		fmt.Println(k, ":", v)
	})
}

Output:

key : 42

func Prepend 

func Prepend[K any, V any](seq iter.Seq2[K, V], key K, value V) iter.Seq2[K, V]

Prepend prepends element to the beginning of a sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"b": 2, "c": 3})
	input = seq2.Sort(input)

	// Prepend a new key-value pair to the sequence
	prepended := seq2.Prepend(input, "a", 1)

	result := seq2.Collect(prepended)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func Reduce 

func Reduce[K any, V any, R any](seq2 iter.Seq2[K, V], accumulator func(agg R, key K, value V) R, initial R) R

Reduce applies a function against an accumulator and each element in the sequence (from left to right) to reduce it to a single value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	type Reduced struct {
		Key   string
		Value int
	}

	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Reduce to calculate the sum of all values
	reduced := seq2.Reduce(input, func(agg Reduced, key string, value int) Reduced {
		return Reduced{
			Key:   agg.Key + key,
			Value: agg.Value + value,
		}
	}, Reduced{})

	fmt.Println(reduced)
}

Output:

{abc 6}

func ReduceRight 

func ReduceRight[K any, V any, R any](seq2 iter.Seq2[K, V], accumulator func(agg R, key K, value V) R, initial R) R

ReduceRight applies a function against an accumulator and each element in the sequence (from right to left) to reduce it to a single value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	type Reduced struct {
		Key   string
		Value int
	}

	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Reduce to calculate the sum of all values
	reduced := seq2.ReduceRight(input, func(agg Reduced, key string, value int) Reduced {
		return Reduced{
			Key:   agg.Key + key,
			Value: agg.Value + value,
		}
	}, Reduced{})

	fmt.Println(reduced)
}

Output:

{cba 6}

func Repeat 

func Repeat[K any, V any](key K, value V, count int) iter.Seq2[K, V]

Repeat repeats the given pair `count` times.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence that repeats a key-value pair 3 times
	repeated := seq2.Repeat("key", 42, 3)

	seq2.ForEach(repeated, func(k string, v int) {
		fmt.Println(k, ":", v)
	})
}

Output:

key : 42
key : 42
key : 42

func Reverse 

func Reverse[K, V any](seq iter.Seq2[K, V]) iter.Seq2[K, V]

Reverse reverses the given sequence.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create an indexed sequence
	sequence := seq2.Of("a", "b", "c")

	// Reverse it
	reversed := seq2.Reverse(sequence)

	// Collect into pairs for ordered display
	var pairs []string
	seq2.ForEach(reversed, func(k int, v string) {
		fmt.Println(k, ":", v)
	})

	fmt.Println(strings.Join(pairs, ", "))
}

Output:

2 : c
1 : b
0 : a

func Skip 

func Skip[K any, V any](seq iter.Seq2[K, V], n int) iter.Seq2[K, V]

Skip returns a new sequence that skips the first n elements of the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of(10, 20, 30, 40, 20)

	// Skip the first 2 elements
	skipped := seq2.Skip(input, 2)

	result := seq2.Collect(skipped)
	fmt.Println(result)
}

Output:

map[2:30 3:40 4:20]

func SkipUntil 

func SkipUntil[K any, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

SkipUntil returns a new sequence that skips elements from the given sequence until the predicate is satisfied.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of(10, 20, 30, 40, 20)

	// Skip elements until value of 30 is reached
	skipped := seq2.SkipUntil(input, func(k int, v int) bool {
		return v == 30
	})

	result := seq2.Collect(skipped)
	fmt.Println(result)
}

Output:

map[2:30 3:40 4:20]

func SkipWhile 

func SkipWhile[K any, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

SkipWhile returns a new sequence that skips elements from the given sequence while the predicate is satisfied.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of(10, 20, 30, 40, 20)

	// Skip elements until the value is less than 30
	skipped := seq2.SkipWhile(input, func(k int, v int) bool {
		return v < 30
	})

	result := seq2.Collect(skipped)
	fmt.Println(result)
}

Output:

map[2:30 3:40 4:20]

func Sort 

func Sort[K types.Ordered, V any](seq iter.Seq2[K, V]) iter.Seq2[K, V]

Sort sorts the elements of a sequence by key in ascending order.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Pair("a", 1)
	input = seq2.Append(input, "c", 3)
	input = seq2.Append(input, "b", 2)

	// Sort by keys (alphabetically)
	sorted := seq2.Sort(input)

	seq2.ForEach(sorted, func(k string, v int) {
		fmt.Println(k, ":", v)
	})
}

Output:

a : 1
b : 2
c : 3

func SortBy 

func SortBy[K any, V any, R types.Ordered](seq iter.Seq2[K, V], mapper func(K, V) R) iter.Seq2[K, V]

SortBy sorts the elements of a sequence by result of the mapper.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Pair("a", 1)
	input = seq2.Append(input, "c", 3)
	input = seq2.Append(input, "b", 2)

	// Sort by values
	sorted := seq2.SortBy(input, func(k string, v int) int {
		return v
	})

	seq2.ForEach(sorted, func(k string, v int) {
		fmt.Println(k, ":", v)
	})
}

Output:

a : 1
b : 2
c : 3

func SortComparingKeys 

func SortComparingKeys[K any, V any](seq iter.Seq2[K, V], cmp func(K, K) int) iter.Seq2[K, V]

SortComparingKeys sorts the elements of a sequence by key in ascending order.

Example 
package main

import (
	"cmp"
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Pair("a", 1)
	input = seq2.Append(input, "c", 3)
	input = seq2.Append(input, "b", 2)

	// Sort by keys in reverse order
	sorted := seq2.SortComparingKeys(input, func(a, b string) int {
		return -cmp.Compare(a, b)
	})

	seq2.ForEach(sorted, func(k string, v int) {
		fmt.Println(k, ":", v)
	})
}

Output:

c : 3
b : 2
a : 1

func SortComparingValues 

func SortComparingValues[K any, V any](seq iter.Seq2[K, V], cmp func(V, V) int) iter.Seq2[K, V]

SortComparingValues sorts the elements of a sequence by value in ascending order.

Example 
package main

import (
	"cmp"
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Unordered map with string keys
	input := seq2.Pair("a", 1)
	input = seq2.Append(input, "c", 3)
	input = seq2.Append(input, "b", 2)

	// Sort by values in descending order
	sorted := seq2.SortComparingValues(input, func(a, b int) int {
		return -cmp.Compare(a, b)
	})

	seq2.ForEach(sorted, func(k string, v int) {
		fmt.Println(k, ":", v)
	})
}

Output:

c : 3
b : 2
a : 1

func Split 

func Split[K any, V any](seq iter.Seq2[K, V]) (iter.Seq[K], iter.Seq[V])

Split splits a sequence of pairs into two sequences.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// Split is an alias for UnZip
	keys, values := seq2.Split(input)

	keySlice := make([]string, 0)
	for k := range keys {
		keySlice = append(keySlice, k)
	}
	fmt.Printf("Keys: %v\n", keySlice)

	valueSlice := make([]int, 0)
	for v := range values {
		valueSlice = append(valueSlice, v)
	}
	fmt.Printf("Values: %v\n", valueSlice)
}

Output:

Keys: [a b c]
Values: [1 2 3]

func Take 

func Take[K any, V any](seq iter.Seq2[K, V], n int) iter.Seq2[K, V]

Take returns a new sequence that contains only the first n elements of the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Take the first 2 elements
	taken := seq2.Take(input, 2)

	result := seq2.Collect(taken)
	fmt.Println(result)
}

Output:

map[a:1 b:2]

func TakeUntil 

func TakeUntil[K any, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

TakeUntil returns a new sequence that takes elements from the given sequence until the predicate is satisfied.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Take elements until value is greater than 2
	taken := seq2.TakeUntil(input, func(k string, v int) bool {
		return v > 2
	})

	result := seq2.Collect(taken)
	fmt.Println(result)
}

Output:

map[a:1 b:2]

func TakeWhile 

func TakeWhile[K any, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

TakeWhile returns a new sequence that takes elements from the given sequence while the predicate is satisfied.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of("a", "b", "c", "d")

	// Take elements while value is less than 3
	taken := seq2.TakeWhile(input, func(k int, v string) bool {
		return v != "c"
	})

	result := seq2.Collect(taken)
	fmt.Println(result)
}

Output:

map[0:a 1:b]

func Tap 

func Tap[K any, V any](seq iter.Seq2[K, V], consumer Consumer[K, V]) iter.Seq2[K, V]

Tap returns a sequence that applies the given consumer to each element of the input sequence and pass it further.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	// Ensure to have consistent output
	input = seq2.Sort(input)

	// Use Tap to print key-value pairs while passing them through
	tapped := seq2.Tap(input, func(k string, v int) {
		fmt.Printf("Processing: %s => %d\n", k, v)
	})

	seq2.Flush(tapped)

}

Output:

Processing: a => 1
Processing: b => 2
Processing: c => 3

func Tick 

func Tick(d time.Duration) iter.Seq2[int, time.Time]

Tick returns a sequence that yields the tick number and the current time every duration.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	ticker := seq2.Tick(1 * time.Millisecond)

	ticker = seq2.Take(ticker, 5)

	seq2.ForEach(ticker, func(tick int, v time.Time) {
		fmt.Printf("tick %d at %s \n", tick, v.Format("15:04:05.000"))
	})

	// Example Output:
	// tick 1 at 00:00:00.000
	// tick 2 at 00:00:00.001
	// tick 3 at 00:00:00.002
	// tick 4 at 00:00:00.003
	// tick 5 at 00:00:00.004
}

func ToMap 

func ToMap[Map ~map[K]V, K comparable, V any](seq iter.Seq2[K, V], m Map)

ToMap collects the elements of the given sequence into a map.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	result := make(map[string]int, 3)
	seq2.ToMap(input, result)

	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func UnZip 

func UnZip[K any, V any](seq iter.Seq2[K, V]) (iter.Seq[K], iter.Seq[V])

UnZip splits a sequence of pairs into two sequences.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	input = seq2.Sort(input)

	// UnZip splits a sequence into keys and values sequences
	keys, values := seq2.UnZip(input)

	keySlice := make([]string, 0)
	for k := range keys {
		keySlice = append(keySlice, k)
	}
	fmt.Printf("Keys: %v\n", keySlice)

	valueSlice := make([]int, 0)
	for v := range values {
		valueSlice = append(valueSlice, v)
	}
	fmt.Printf("Values: %v\n", valueSlice)
}

Output:

Keys: [a b c]
Values: [1 2 3]
Example (AfterZip) 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	nums := seq.Of(1, 2, 3)
	letters := seq.Of("a", "b", "c")

	zipped := seq.Zip(nums, letters)

	unzipped1, unzipped2 := seq2.UnZip(zipped)

	result1 := seq.Collect(unzipped1)
	result2 := seq.Collect(unzipped2)

	fmt.Println(result1)
	fmt.Println(result2)
}

Output:

[1 2 3]
[a b c]

func Union 

func Union[K comparable, V comparable](seq1 iter.Seq2[K, V], seq2 iter.Seq2[K, V]) iter.Seq2[K, V]

Union returns a sequence that contains all distinct elements from both input sequences.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	first := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3})
	first = seq2.Sort(first)
	second := seq2.FromMap(map[string]int{"c": 3, "d": 4, "e": 5})
	second = seq2.Sort(second)

	// Union returns distinct elements from both sequences
	combined := seq2.Union(first, second)

	result := seq2.Collect(combined)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3 d:4 e:5]

func UnionAll 

func UnionAll[K any, V any](seq1 iter.Seq2[K, V], seq2 iter.Seq2[K, V]) iter.Seq2[K, V]

UnionAll returns a sequence that contains all elements from both input sequences.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	first := seq2.FromMap(map[string]int{"a": 1, "b": 2})
	first = seq2.Sort(first)
	second := seq2.FromMap(map[string]int{"c": 3, "b": 2})
	second = seq2.Sort(second)

	// UnionAll is an alias for Concat
	combined := seq2.UnionAll(first, second)

	result := seq2.Collect(combined)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func Uniq 

func Uniq[K comparable, V comparable](seq iter.Seq2[K, V]) iter.Seq2[K, V]

Uniq returns a new sequence that contains only the unique elements of the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence with duplicate key-value pairs
	input := seq2.Concat(
		seq2.FromMap(map[string]int{"a": 1, "b": 2}),
		seq2.FromMap(map[string]int{"a": 1, "c": 3}),
	)

	// Get unique key-value pairs
	unique := seq2.Uniq(input)

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:3]

func UniqBy 

func UniqBy[K any, V any, K2 comparable](seq iter.Seq2[K, V], mapper Mapper[K, V, K2]) iter.Seq2[K, V]

UniqBy returns a new sequence that contains only the unique elements of the given sequence based on a key.

Example 
package main

import (
	"fmt"
	"strconv"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"apple": 1, "banana": 2, "apricot": 3, "berry": 4, "blueberry": 5})
	input = seq2.Sort(input)

	// Get unique entries based on first letter and value modulo 2
	unique := seq2.UniqBy(input, func(k string, v int) string {
		return string(k[0]) + strconv.Itoa(v%2)
	})

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[apple:1 banana:2 blueberry:5]

func UniqByKeys 

func UniqByKeys[K any, V any, K2 comparable](seq iter.Seq2[K, V], mapper KeyMapper[K, K2]) iter.Seq2[K, V]

UniqByKeys returns a new sequence that contains only the unique elements of the given sequence based on a key.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"Apple": 1, "apricot": 2, "Banana": 3, "berry": 4})
	input = seq2.Sort(input)

	// Get unique entries based on lowercase first letter of key
	unique := seq2.UniqByKeys(input, func(k string) string {
		return strings.ToLower(string(k[0]))
	})

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[Apple:1 Banana:3]

func UniqByValues 

func UniqByValues[K any, V any, V2 comparable](seq iter.Seq2[K, V], mapper ValueMapper[V, V2]) iter.Seq2[K, V]

UniqByValues returns a new sequence that contains only the unique elements of the given sequence based on a key.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 10, "b": 21, "c": 30, "d": 44})
	input = seq2.Sort(input)

	// Get unique entries based on value modulo 10
	unique := seq2.UniqByValues(input, func(v int) int {
		return v % 10
	})

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[a:10 b:21 d:44]

func UniqKeys 

func UniqKeys[K comparable, V any](seq iter.Seq2[K, V]) iter.Seq2[K, V]

UniqKeys returns a new sequence that contains only the unique keys of the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence with duplicate keys
	input := seq2.Concat(
		seq2.FromMap(map[string]int{"a": 1, "b": 2}),
		seq2.FromMap(map[string]int{"a": 3, "c": 4}),
	)

	// Get entries with unique keys (first occurrence wins)
	unique := seq2.UniqKeys(input)

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[a:1 b:2 c:4]

func UniqValues 

func UniqValues[K any, V comparable](seq iter.Seq2[K, V]) iter.Seq2[K, V]

UniqValues returns a new sequence that contains only the unique values of the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a sequence with duplicate values
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 1, "d": 3})
	input = seq2.Sort(input)

	// Get entries with unique values (first occurrence wins)
	unique := seq2.UniqValues(input)

	result := seq2.Collect(unique)
	fmt.Println(result)
}

Output:

map[a:1 b:2 d:3]

func Values 

func Values[K, V any](seq iter.Seq2[K, V]) iter.Seq[V]

Values returns a sequence of values from a sequence of key-value pairs.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.Of("a", "b", "c")

	keys := seq2.Values(input)

	seq.ForEach(keys, func(v string) {
		fmt.Print(v, " ")
	})
}

Output:

a b c

func Where 

func Where[K any, V any](seq iter.Seq2[K, V], predicate Predicate[K, V]) iter.Seq2[K, V]

Where returns a new sequence that contains only the elements that satisfy the predicate. SQL-like alias for Filter

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	input := seq2.FromMap(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4})
	input = seq2.Sort(input)

	// Where is an alias for Filter
	filtered := seq2.Where(input, func(k string, v int) bool {
		return v > 2
	})

	result := seq2.Collect(filtered)
	fmt.Println(result)
}

Output:

map[c:3 d:4]

func WithIndex 

func WithIndex[E any](seq iter.Seq[E]) iter.Seq2[int, E]

WithIndex creates a new indexed sequence from the given sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create a iter.Seq of values
	values := seq.Of("a", "b", "c")

	// Add indexes
	indexed := seq2.WithIndex(values)

	result := seq2.Collect(indexed)
	fmt.Println(result)
}

Output:

map[0:a 1:b 2:c]

func WithoutIndex 

func WithoutIndex[E any](indexed iter.Seq2[int, E]) iter.Seq[E]

WithoutIndex creates a new sequence from the given indexed sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Create an indexed sequence
	indexed := seq2.Of("a", "b", "c")

	// Remove indexes
	values := seq2.WithoutIndex(indexed)

	result := seq.Collect(values)
	fmt.Println(result)
}

Output:

[a b c]

Types

type Consumer 

type Consumer[K any, V any] = func(K, V)

Consumer is a function that consumes an element of an iter.Seq2.

type DoubleMapper 

type DoubleMapper[K, V, RK, RV any] = func(K, V) (RK, RV)

DoubleMapper is a function that takes an element and returns a new sequence element.

type KeyMapper 

type KeyMapper[K, R any] = func(K) R

KeyMapper is a function that takes Key a new Key.

type KeyPredicate 

type KeyPredicate[E any] = KeyMapper[E, bool]

KeyPredicate is a function that is used to filter by key.

type Mapper 

type Mapper[K, V, R any] = func(K, V) R

Mapper is a function that takes an element and returns a new element.

type Predicate 

type Predicate[K any, V any] = Mapper[K, V, bool]

Predicate is a function that takes an element and returns a boolean.

type Sequence 

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

Sequence is a wrapper around iter.Seq2 that provides fluent API for seq2 operations.

func AsSequence 

func AsSequence[K comparable, V comparable](seq iter.Seq2[K, V]) Sequence[K, V]

AsSequence wraps an iter.Seq2 to provide a fluent API.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	var result []string
	sequence.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 2:c

func ConcatSequences 

func ConcatSequences[K comparable, V comparable](sequences ...Sequence[K, V]) Sequence[K, V]

ConcatSequences concatenates multiple sequences into a single sequence.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sq1 := seq2.AsSequence(seq2.Of("a", "b"))
	sq2 := seq2.AsSequence(seq2.Of("c", "d"))

	concatenated := seq2.ConcatSequences(sq1, sq2)

	concatenated.ForEach(func(k int, v string) {
		fmt.Println(k, v)
	})

}

Output:

0 a
1 b
0 c
1 d

func (Sequence[K, V]) Append 

func (s Sequence[K, V]) Append(key K, value V) Sequence[K, V]

Append appends a key-value pair to the end of a sequence.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))
	appended := sequence.Append(3, "d")

	var result []string
	appended.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 2:c, 3:d

func (Sequence[K, V]) Collect 

func (s Sequence[K, V]) Collect() map[K]V

Collect collects the elements into a map.

func (Sequence[K, V]) Contains 

func (s Sequence[K, V]) Contains(key K) bool

Contains returns true if the sequence contains the key.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	fmt.Println("Contains key 1:", sequence.Contains(1))
	fmt.Println("Contains key 5:", sequence.Contains(5))
}

Output:

Contains key 1: true
Contains key 5: false

func (Sequence[K, V]) ContainsPair 

func (s Sequence[K, V]) ContainsPair(key K, value V) bool

ContainsPair returns true if the sequence contains the key-value pair.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	fmt.Println("Contains pair 1:'b':", sequence.ContainsPair(1, "b"))
	fmt.Println("Contains pair 1:'c':", sequence.ContainsPair(1, "c"))
}

Output:

Contains pair 1:'b': true
Contains pair 1:'c': false

func (Sequence[K, V]) ContainsValue 

func (s Sequence[K, V]) ContainsValue(value V) bool

ContainsValue returns true if the sequence contains the value.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	fmt.Println("Contains value 'b':", sequence.ContainsValue("b"))
	fmt.Println("Contains value 'z':", sequence.ContainsValue("z"))
}

Output:

Contains value 'b': true
Contains value 'z': false

func (Sequence[K, V]) Count 

func (s Sequence[K, V]) Count() int

Count returns the number of elements in the sequence.

func (Sequence[K, V]) Cycle 

func (s Sequence[K, V]) Cycle(count int) Sequence[K, V]

Cycle repeats the sequence the specified number of times.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b"))
	cycled := sequence.Cycle(2)

	var result []string
	cycled.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 0:a, 1:b

func (Sequence[K, V]) Distinct 

func (s Sequence[K, V]) Distinct() Sequence[K, V]

Distinct is an alias for Uniq.

func (Sequence[K, V]) Each 

func (s Sequence[K, V]) Each(consumer Consumer[K, V]) Sequence[K, V]

Each is an alias for Tap.

func (Sequence[K, V]) Every 

func (s Sequence[K, V]) Every(predicate Predicate[K, V]) bool

Every returns true if all elements satisfy the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	allLowercase := sequence.Every(func(k int, v string) bool {
		return v >= "a" && v <= "z"
	})

	allA := sequence.Every(func(k int, v string) bool {
		return v == "a"
	})

	fmt.Println("All values lowercase:", allLowercase)
	fmt.Println("All values 'a':", allA)
}

Output:

All values lowercase: true
All values 'a': false

func (Sequence[K, V]) Exists 

func (s Sequence[K, V]) Exists(predicate Predicate[K, V]) bool

Exists returns true if any element satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	hasValueB := sequence.Exists(func(k int, v string) bool {
		return v == "b"
	})

	fmt.Println("Has value 'b':", hasValueB)
}

Output:

Has value 'b': true

func (Sequence[K, V]) Filter 

func (s Sequence[K, V]) Filter(predicate Predicate[K, V]) Sequence[K, V]

Filter returns a new sequence with elements that satisfy the predicate.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c", "d", "e"))
	filtered := sequence.Filter(func(k int, v string) bool {
		return k%2 == 0
	})

	var result []string
	filtered.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 2:c, 4:e

func (Sequence[K, V]) FilterByKey 

func (s Sequence[K, V]) FilterByKey(predicate KeyPredicate[K]) Sequence[K, V]

FilterByKey returns a new sequence with elements whose keys satisfy the predicate.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c", "d", "e"))
	filtered := sequence.FilterByKey(func(k int) bool {
		return k > 2
	})

	var result []string
	filtered.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

3:d, 4:e

func (Sequence[K, V]) FilterByValue 

func (s Sequence[K, V]) FilterByValue(predicate ValuePredicate[V]) Sequence[K, V]

FilterByValue returns a new sequence with elements whose values satisfy the predicate.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c", "d", "e"))
	filtered := sequence.FilterByValue(func(v string) bool {
		return v > "c"
	})

	var result []string
	filtered.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

3:d, 4:e

func (Sequence[K, V]) Find 

func (s Sequence[K, V]) Find(predicate Predicate[K, V]) (optional.Elem[K], optional.Elem[V])

Find returns the first element that satisfies the predicate.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c", "d", "e"))

	key, value := sequence.Find(func(k int, v string) bool {
		return v == "c"
	})

	fmt.Printf("Key: %d, Value: %s\n", key.MustGet(), value.MustGet())
}

Output:

Key: 2, Value: c

func (Sequence[K, V]) FindAll 

func (s Sequence[K, V]) FindAll(predicate Predicate[K, V]) Sequence[K, V]

FindAll returns all elements that satisfy the predicate.

func (Sequence[K, V]) FindLast 

func (s Sequence[K, V]) FindLast(predicate Predicate[K, V]) (optional.Elem[K], optional.Elem[V])

FindLast returns the last element that satisfies the predicate.

func (Sequence[K, V]) Flush 

func (s Sequence[K, V]) Flush()

Flush consumes all elements of the sequence.

func (Sequence[K, V]) FoldValues 

func (s Sequence[K, V]) FoldValues(accumulator func(agg V, key K, value V) V) optional.Elem[V]

FoldValues folds values with the first value as initial.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	result := sequence.FoldValues(func(agg string, key int, value string) string {
		return agg + value
	})

	fmt.Println("Concatenated:", result.MustGet())
}

Output:

Concatenated: abc

func (Sequence[K, V]) FoldValuesRight 

func (s Sequence[K, V]) FoldValuesRight(accumulator func(agg V, key K, value V) V) optional.Elem[V]

FoldValuesRight folds values from right to left.

func (Sequence[K, V]) ForEach 

func (s Sequence[K, V]) ForEach(consumer Consumer[K, V])

ForEach calls the consumer for each element.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	var result []string
	sequence.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 2:c

func (Sequence[K, V]) Get 

func (s Sequence[K, V]) Get(key K) optional.Elem[V]

Get returns the value associated with the key.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))

	existing := sequence.Get(1)
	notExisting := sequence.Get(5)

	fmt.Println("Value for key 1:", existing.MustGet())
	fmt.Println("Has value for key 5:", notExisting.IsPresent())
}

Output:

Value for key 1: b
Has value for key 5: false

func (Sequence[K, V]) IsEmpty 

func (s Sequence[K, V]) IsEmpty() bool

IsEmpty returns true if the sequence is empty.

func (Sequence[K, V]) IsNotEmpty 

func (s Sequence[K, V]) IsNotEmpty() bool

IsNotEmpty returns true if the sequence is not empty.

func (Sequence[K, V]) Keys 

func (s Sequence[K, V]) Keys() iter.Seq[K]

Keys returns a sequence of keys.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))
	keys := sequence.Keys()

	seq.ForEach(keys, func(k int) {
		fmt.Println(k)
	})
}

Output:

0
1
2

func (Sequence[K, V]) Limit 

func (s Sequence[K, V]) Limit(n int) Sequence[K, V]

Limit is an alias for Take.

func (Sequence[K, V]) None 

func (s Sequence[K, V]) None(predicate Predicate[K, V]) bool

None returns true if no element satisfies the predicate.

func (Sequence[K, V]) NotContains 

func (s Sequence[K, V]) NotContains(key K) bool

NotContains returns true if the sequence does not contain the key.

func (Sequence[K, V]) NotContainsPair 

func (s Sequence[K, V]) NotContainsPair(key K, value V) bool

NotContainsPair returns true if the sequence does not contain the key-value pair.

func (Sequence[K, V]) NotContainsValue 

func (s Sequence[K, V]) NotContainsValue(value V) bool

NotContainsValue returns true if the sequence does not contain the value.

func (Sequence[K, V]) Offset 

func (s Sequence[K, V]) Offset(n int) Sequence[K, V]

Offset is an alias for Skip.

func (Sequence[K, V]) Prepend 

func (s Sequence[K, V]) Prepend(key K, value V) Sequence[K, V]

Prepend prepends a key-value pair to the beginning of a sequence.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("b", "c", "d"))
	prepended := sequence.Prepend(-1, "a")

	var result []string
	prepended.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

-1:a, 0:b, 1:c, 2:d

func (Sequence[K, V]) Repeat 

func (s Sequence[K, V]) Repeat(count int) Sequence[K, V]

Repeat is an alias for Cycle.

func (Sequence[K, V]) Reverse 

func (s Sequence[K, V]) Reverse() Sequence[K, V]

Reverse returns a new sequence with elements in reverse order.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))
	reversed := sequence.Reverse()

	var result []string
	reversed.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

2:c, 1:b, 0:a

func (Sequence[K, V]) Skip 

func (s Sequence[K, V]) Skip(n int) Sequence[K, V]

Skip returns a new sequence that skips the first n elements.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c", "d", "e"))
	skipped := sequence.Skip(2)

	var result []string
	skipped.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

2:c, 3:d, 4:e

func (Sequence[K, V]) SortComparingKeys 

func (s Sequence[K, V]) SortComparingKeys(compare func(K, K) int) Sequence[K, V]

SortComparingKeys sorts the sequence by keys using a custom comparator.

func (Sequence[K, V]) SortComparingValues 

func (s Sequence[K, V]) SortComparingValues(compare func(V, V) int) Sequence[K, V]

SortComparingValues sorts the sequence by values using a custom comparator.

func (Sequence[K, V]) Take 

func (s Sequence[K, V]) Take(n int) Sequence[K, V]

Take returns a new sequence with only the first n elements.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c", "d", "e"))
	taken := sequence.Take(3)

	var result []string
	taken.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 2:c

func (Sequence[K, V]) Tap 

func (s Sequence[K, V]) Tap(consumer Consumer[K, V]) Sequence[K, V]

Tap calls the consumer for each element without changing the sequence.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	var result []string
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c")).
		Tap(func(k int, v string) {
			result = append(result, fmt.Sprintf("%d:%s", k, v))
		})

	sequence.Flush()
	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 2:c

func (Sequence[K, V]) ToMap 

func (s Sequence[K, V]) ToMap(m map[K]V)

ToMap converts the sequence to a map.

func (Sequence[K, V]) Union 

func (s Sequence[K, V]) Union(other Sequence[K, V]) Sequence[K, V]

Union returns a new sequence that contains all distinct elements from both input sequences.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sq1 := seq2.AsSequence(seq2.Concat(seq2.Pair("a", 1), seq2.Pair("b", 2), seq2.Pair("c", 3)))
	sq2 := seq2.AsSequence(seq2.Concat(seq2.Pair("a", 1), seq2.Pair("d", 4), seq2.Pair("e", 5)))

	union := sq1.Union(sq2)

	union.ForEach(func(k string, v int) {
		fmt.Println(k, ":", v)
	})

}

Output:

a : 1
b : 2
c : 3
d : 4
e : 5

func (Sequence[K, V]) UnionAll 

func (s Sequence[K, V]) UnionAll(other Sequence[K, V]) Sequence[K, V]

UnionAll returns a new sequence that contains all elements from both input sequences.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	seq1 := seq2.AsSequence(seq2.Of("a", "b", "c"))
	seq2Inst := seq2.AsSequence(seq2.Of("c", "d", "e"))

	unionAll := seq1.UnionAll(seq2Inst)

	var result []string
	unionAll.ForEach(func(k int, v string) {
		result = append(result, fmt.Sprintf("%d:%s", k, v))
	})

	fmt.Println(strings.Join(result, ", "))
}

Output:

0:a, 1:b, 2:c, 0:c, 1:d, 2:e

func (Sequence[K, V]) Uniq 

func (s Sequence[K, V]) Uniq() Sequence[K, V]

Uniq returns a sequence with unique key-value pairs.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	// Using FromMap to create a sequence with duplicate values
	sequence := seq2.AsSequence(seq2.Of("a", "a", "b", "b", "c"))
	unique := sequence.UniqValues()

	unique.ForEach(func(k int, v string) {
		fmt.Println(k, ":", v)
	})

}

Output:

0 : a
2 : b
4 : c

func (Sequence[K, V]) UniqKeys 

func (s Sequence[K, V]) UniqKeys() Sequence[K, V]

UniqKeys returns a sequence with unique keys.

func (Sequence[K, V]) UniqValues 

func (s Sequence[K, V]) UniqValues() Sequence[K, V]

UniqValues returns a sequence with unique values.

func (Sequence[K, V]) Values 

func (s Sequence[K, V]) Values() iter.Seq[V]

Values returns a sequence of values.

Example 
package main

import (
	"fmt"

	"github.com/go-softwarelab/common/pkg/seq"
	"github.com/go-softwarelab/common/pkg/seq2"
)

func main() {
	sequence := seq2.AsSequence(seq2.Of("a", "b", "c"))
	values := sequence.Values()

	seq.ForEach(values, func(v string) {
		fmt.Println(v)
	})
}

Output:

a
b
c

func (Sequence[K, V]) Where 

func (s Sequence[K, V]) Where(predicate Predicate[K, V]) Sequence[K, V]

Where returns a new sequence with elements that satisfy the predicate.

type ValueMapper 

type ValueMapper[V, R any] = func(V) R

ValueMapper is a function that takes Value a new Value.

type ValuePredicate 

type ValuePredicate[E any] = ValueMapper[E, bool]

ValuePredicate is a function that is used to filter by value.

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.