itertools

README

itertools

Package itertools contains iterator functions like Zip.

Examples

package main

import (
    "fmt"
    "slices"

    "github.com/keep94/itertools"
)

func main() {
    lettersIter := slices.Values([]string{"a", "b", "c"})
    numbersIter := slices.Values([]int{1, 2, 3})

    // Prints:
    // a 1
    // b 2
    // c 3
    for letter, number := range itertools.Zip(lettersIter, numbersIter) {
        fmt.Println(letter, number)
    }
}

More documentation and examples can be found here.

Documentation

Overview

Package itertools contains iterator functions like Zip.

Index

• func Chain[T any](sequences ...iter.Seq[T]) iter.Seq[T]
• func Count(start, step int) iter.Seq[int]
• func Cycle[T any](seq iter.Seq[T]) iter.Seq[T]
• func CycleValues[T any](values ...T) iter.Seq[T]
• func Enumerate[T any](seq iter.Seq[T]) iter.Seq2[int, T]
• func Filter[T any](f Filterer[T], seq iter.Seq[T]) iter.Seq[T]
• func Map[T, U any](m Mapper[T, U], seq iter.Seq[T]) iter.Seq[U]
• func PairUp[F, S any](seq iter.Seq2[F, S]) iter.Seq[Pair[F, S]]
• func Take[T any](n int, seq iter.Seq[T]) iter.Seq[T]
• func TakeWhile[T any](f Filterer[T], seq iter.Seq[T]) iter.Seq[T]
• func Zip[F, S any](first iter.Seq[F], second iter.Seq[S]) iter.Seq2[F, S]
• type Filterer
• type Mapper
• type Pair

Examples

• Chain
• Enumerate
• TakeWhile
• Zip

Functions

func Chain

func Chain[T any](sequences ...iter.Seq[T]) iter.Seq[T]

Chain returns all the elements in the first sequence followed by all the elements in the second sequence etc.

Example

package main

import (
	"fmt"
	"slices"

	"github.com/keep94/itertools"
)

func main() {
	notes := []string{"do", "re", "mi", "fa", "so"}
	ordinals := []int{1, 2, 3}
	notesIter := slices.Values(notes)
	ordinalsIter := itertools.Chain(
		slices.Values(ordinals), itertools.CycleValues(0))
	for n, o := range itertools.Zip(notesIter, ordinalsIter) {
		fmt.Println(n, o)
	}
}

Output:

do 1
re 2
mi 3
fa 0
so 0

func Count

func Count(start, step int) iter.Seq[int]

Count returns start, start + step, start + 2*step, ...

func Cycle

func Cycle[T any](seq iter.Seq[T]) iter.Seq[T]

Cycle returns the values in seq repeating in an infinite cycle.

func CycleValues

func CycleValues[T any](values ...T) iter.Seq[T]

CycleValues returns values repeating in an infinite cycle.

func Enumerate

func Enumerate[T any](seq iter.Seq[T]) iter.Seq2[int, T]

Enumerate works like enumerate in python. It is equivalent to Zip(Count(0, 1), seq)

Example

package main

import (
	"fmt"
	"slices"

	"github.com/keep94/itertools"
)

func main() {
	notesIter := slices.Values([]string{"do", "re", "mi", "fa", "so"})
	for i, n := range itertools.Enumerate(notesIter) {
		fmt.Println(i, n)
	}
}

Output:

0 do
1 re
2 mi
3 fa
4 so

func Filter

func Filter[T any](f Filterer[T], seq iter.Seq[T]) iter.Seq[T]

Filter returns an iter.Seq[T] that contains all the T values in seq for which f returns true.

func Map

func Map[T, U any](m Mapper[T, U], seq iter.Seq[T]) iter.Seq[U]

Map returns an iter.Seq[U] which is m applied to each element in seq.

func PairUp

func PairUp[F, S any](seq iter.Seq2[F, S]) iter.Seq[Pair[F, S]]

PairUp converts an iter.Seq2 into an iter.Seq of pairs.

func Take

func Take[T any](n int, seq iter.Seq[T]) iter.Seq[T]

Take returns the first n elements of seq.

func TakeWhile

func TakeWhile[T any](f Filterer[T], seq iter.Seq[T]) iter.Seq[T]

TakeWhile returns the first elements of seq for which f returns true.

Example

package main

import (
	"fmt"

	"github.com/keep94/itertools"
)

func main() {
	seq := itertools.CycleValues(1, 2, 3, 4, 5)
	f := func(x int) bool { return x < 4 }
	for x := range itertools.TakeWhile(f, seq) {
		fmt.Println(x)
	}
}

Output:

1
2
3

func Zip

func Zip[F, S any](first iter.Seq[F], second iter.Seq[S]) iter.Seq2[F, S]

Zip works like zip in python.

Example

package main

import (
	"fmt"
	"slices"

	"github.com/keep94/itertools"
)

func main() {
	notesIter := slices.Values([]string{"do", "re", "mi", "fa", "so"})
	ordinalsIter := slices.Values([]int{1, 2, 3})
	for n, o := range itertools.Zip(notesIter, ordinalsIter) {
		fmt.Println(n, o)
	}
}

Output:

do 1
re 2
mi 3

Types

type Filterer

type Filterer[T any] func(T) bool

Filterer filters T values.

type Mapper

type Mapper[T, U any] func(T) U

Mapper maps T values to U values.

type Pair

type Pair[F, S any] struct {
	First  F
	Second S
}

Pair represents a pair of values.