iter

package
v2.0.0-alpha.3 Latest Latest
Warning

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

 Go to latest Published: Jun 2, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Count 

func Count[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64]() iter.Seq[V]

Count yields all non-negative integers in ascending order.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for i := range iter.Count[int]() {
		if i >= 3 {
			break
		}

		fmt.Println(i)
	}

}

Output:

0
1
2

func Drop 

func Drop[V any](delegate iter.Seq[V], count int) iter.Seq[V]

Drop yields all values from a delegate Iterator except the first `count` values.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for value := range iter.Drop(slices.Values([]int{1, 2, 3, 4, 5}), 2) {
		fmt.Println(value)
	}

}

Output:

3
4
5
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for value := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Drop(2) {
		fmt.Println(value)
	}

}

Output:

3
4
5

func Drop2 

func Drop2[V, W any](delegate iter.Seq2[V, W], count int) iter.Seq2[V, W]

Drop2 yields all pairs of values from a delegate Iterator2 except the first `count` pairs.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	numbers := maps.Collect(iter.Drop2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 1))

	fmt.Println(len(numbers))
}

Output:

2
Example (Method) 
package main

import (
	"fmt"
	it "iter"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	numbers := iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two", 3: "three"})).Drop(1)

	fmt.Println(len(maps.Collect(it.Seq2[int, string](numbers))))
}

Output:

2

func Enumerate 

func Enumerate[V any](delegate iter.Seq[V]) iter.Seq2[int, V]

Enumerate yields pairs of indices and values from an iterator.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for index, value := range iter.Enumerate(slices.Values([]int{1, 2, 3})) {
		fmt.Println(index, value)
	}

}

Output:

0 1
1 2
2 3
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for index, value := range iter.Iterator[int](slices.Values([]int{1, 2, 3})).Enumerate() {
		fmt.Println(index, value)
	}

}

Output:

0 1
1 2
2 3

func Exclude 

func Exclude[V any](delegate iter.Seq[V], predicate func(V) bool) iter.Seq[V]

Exclude yields values from an iterator that do not satisfy a predicate.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
	"github.com/BooleanCat/go-functional/v2/iter/filter"
)

func main() {
	for number := range iter.Exclude(slices.Values([]int{1, 2, 3, 4, 5}), filter.IsEven) {
		fmt.Println(number)
	}

}

Output:

1
3
5
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
	"github.com/BooleanCat/go-functional/v2/iter/filter"
)

func main() {
	for number := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Exclude(filter.IsEven) {
		fmt.Println(number)
	}

}

Output:

1
3
5

func Exclude2 

func Exclude2[V, W any](delegate iter.Seq2[V, W], predicate func(V, W) bool) iter.Seq2[V, W]

Exclude2 yields values from an iterator that do not satisfy a predicate.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	isOne := func(n int, _ string) bool { return n == 1 }
	numbers := map[int]string{1: "one", 3: "three"}

	for key, value := range iter.Exclude2(maps.All(numbers), isOne) {
		fmt.Println(key, value)
	}

}

Output:

3 three
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	isOne := func(n int, _ string) bool { return n == 1 }
	numbers := map[int]string{1: "one", 3: "three"}

	for key, value := range iter.Iterator2[int, string](maps.All(numbers)).Exclude(isOne) {
		fmt.Println(key, value)
	}

}

Output:

3 three

func Filter 

func Filter[V any](delegate iter.Seq[V], predicate func(V) bool) iter.Seq[V]

Filter yields values from an iterator that satisfy a predicate.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
	"github.com/BooleanCat/go-functional/v2/iter/filter"
)

func main() {
	for number := range iter.Filter(slices.Values([]int{1, 2, 3, 4, 5}), filter.IsEven) {
		fmt.Println(number)
	}

}

Output:

2
4
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
	"github.com/BooleanCat/go-functional/v2/iter/filter"
)

func main() {
	for number := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Filter(filter.IsEven) {
		fmt.Println(number)
	}

}

Output:

2
4

func Filter2 

func Filter2[V, W any](delegate iter.Seq2[V, W], predicate func(V, W) bool) iter.Seq2[V, W]

Filter2 yields values from an iterator that satisfy a predicate.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	isOne := func(n int, _ string) bool { return n == 1 }
	numbers := map[int]string{1: "one", 2: "two", 3: "three"}

	for key, value := range iter.Filter2(maps.All(numbers), isOne) {
		fmt.Println(key, value)
	}

}

Output:

1 one
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	isOne := func(n int, _ string) bool { return n == 1 }
	numbers := map[int]string{1: "one", 2: "two", 3: "three"}

	for key, value := range iter.Iterator2[int, string](maps.All(numbers)).Filter(isOne) {
		fmt.Println(key, value)
	}

}

Output:

1 one

func ForEach 

func ForEach[V any](iter iter.Seq[V], fn func(V))

ForEach consumes an iterator and applies a function to each value yielded.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	iter.ForEach(slices.Values([]int{1, 2, 3}), func(number int) {
		fmt.Println(number)
	})
}

Output:

1
2
3
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	iter.Iterator[int](slices.Values([]int{1, 2, 3})).ForEach(func(number int) {
		fmt.Println(number)
	})
}

Output:

1
2
3

func ForEach2 

func ForEach2[V, W any](iter iter.Seq2[V, W], fn func(V, W))

ForEach2 consumes an iterator and applies a function to each pair of values.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	iter.ForEach2(iter.Enumerate[int](slices.Values([]int{1, 2, 3})), func(index int, number int) {
		fmt.Println(index, number)
	})
}

Output:

0 1
1 2
2 3
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	iter.Iterator[int](slices.Values([]int{1, 2, 3})).Enumerate().ForEach(func(index int, number int) {
		fmt.Println(index, number)
	})
}

Output:

0 1
1 2
2 3

func Map 

func Map[V, W any](delegate iter.Seq[V], transform func(V) W) iter.Seq[W]

Map yields values from an iterator that have been transformed by a function.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	double := func(n int) int { return n * 2 }

	for number := range iter.Map(slices.Values([]int{1, 2, 3}), double) {
		fmt.Println(number)
	}

}

Output:

2
4
6

func Map2 

func Map2[V, W, X, Y any](delegate iter.Seq2[V, W], transform func(V, W) (X, Y)) iter.Seq2[X, Y]

Map2 yields pairs of values from an iterator that have been transformed by a function.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	doubleBoth := func(n, m int) (int, int) { return n * 2, m * 2 }

	for left, right := range iter.Map2(iter.Zip(slices.Values([]int{1, 2, 3}), slices.Values([]int{2, 3, 4})), doubleBoth) {
		fmt.Println(left, right)
	}

}

Output:

2 4
4 6
6 8

func Reduce 

func Reduce[V any, R any](iter iter.Seq[V], fn func(R, V) R, initial R) R

Reduce consumes an iterator and applies a function to each value yielded, accumulating a single result.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
	"github.com/BooleanCat/go-functional/v2/iter/op"
)

func main() {
	fmt.Println(iter.Reduce(slices.Values([]int{1, 2, 3}), op.Add, 0))
}

Output:

6

func Reduce2 

func Reduce2[V, W any, R any](iter iter.Seq2[V, W], fn func(R, V, W) R, initial R) R

Reduce2 consumes an iterator and applies a function to each pair of values, accumulating a single result.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	fmt.Println(iter.Reduce2(iter.Enumerate[int](slices.Values([]int{1, 2, 3})), func(i, a, b int) int {
		return i + 1
	}, 0))

}

Output:

3

func Take 

func Take[V any](delegate iter.Seq[V], limit int) iter.Seq[V]

Take yields the first `limit` values from a delegate Iterator.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for number := range iter.Take(slices.Values([]int{1, 2, 3, 4, 5}), 3) {
		fmt.Println(number)
	}

}

Output:

1
2
3
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for number := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Take(3) {
		fmt.Println(number)
	}

}

Output:

1
2
3

func Take2 

func Take2[V, W any](delegate iter.Seq2[V, W], limit int) iter.Seq2[V, W]

Take2 yields the first `limit` pairs of values from a delegate Iterator2.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	numbers := maps.Collect(iter.Take2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 2))

	fmt.Println(len(numbers))
}

Output:

2
Example (Method) 
package main

import (
	"fmt"
	it "iter"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	numbers := maps.Collect(it.Seq2[int, string](iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two", 3: "three"})).Take(2)))

	fmt.Println(len(numbers))
}

Output:

2

func Unzip 

func Unzip[V, W any](delegate iter.Seq2[V, W]) (iter.Seq[V], iter.Seq[W])

Unzip returns two [Iterator]s from a single Iterator2.

Each returned Iterator yields the left and right values from the original Iterator2, respectively.

It is safe to concurrently pull from the returned [Iterator]s.

Both returned [Iterator]s must be stopped, the underlying Iterator2 is stopped when both are stopped. It is safe to stop one of the returned [Iterator]s immediately and continue pulling from the other.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	keys, values := iter.Unzip(maps.All(map[int]string{1: "one", 2: "two"}))

	for key := range keys {
		fmt.Println(key)
	}

	for value := range values {
		fmt.Println(value)
	}
}
Example (Method) 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/maps"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	keys, values := iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two"})).Unzip()

	for key := range keys {
		fmt.Println(key)
	}

	for value := range values {
		fmt.Println(value)
	}
}

func Zip 

func Zip[V, W any](left iter.Seq[V], right iter.Seq[W]) iter.Seq2[V, W]

Zip yields pairs of values from two iterators.

Example 
package main

import (
	"fmt"

	"github.com/BooleanCat/go-functional/v2/future/slices"
	"github.com/BooleanCat/go-functional/v2/iter"
)

func main() {
	for left, right := range iter.Zip(slices.Values([]int{1, 2, 3}), slices.Values([]string{"one", "two", "three"})) {
		fmt.Println(left, right)
	}

}

Output:

1 one
2 two
3 three

Types

type Iterator 

type Iterator[V any] iter.Seq[V]

Iterator is a wrapper around iter.Seq that allows for method chaining of most iterators found in this package.

func (Iterator[V]) Collect 

func (iterator Iterator[V]) Collect() []V

Collect is a convenience method for chaining [Collect] on [Iterator]s.

func (Iterator[V]) Drop 

func (iterator Iterator[V]) Drop(count int) Iterator[V]

Drop is a convenience method for chaining Drop on [Iterator]s.

func (Iterator[V]) Enumerate 

func (iterator Iterator[V]) Enumerate() Iterator2[int, V]

Enumerate is a convenience method for chaining Enumerate on [Iterator]s.

func (Iterator[V]) Exclude 

func (iterator Iterator[V]) Exclude(predicate func(V) bool) Iterator[V]

Exclude is a convenience method for chaining Exclude on [Iterator]s.

func (Iterator[V]) Filter 

func (iterator Iterator[V]) Filter(predicate func(V) bool) Iterator[V]

Filter is a convenience method for chaining Filter on [Iterator]s.

func (Iterator[V]) ForEach 

func (iterator Iterator[V]) ForEach(fn func(V))

ForEach is a convenience method for chaining ForEach on [Iterator]s.

func (Iterator[V]) Take 

func (iterator Iterator[V]) Take(limit int) Iterator[V]

Take is a convenience method for chaining Take on [Iterator]s.

type Iterator2 

type Iterator2[V, W any] iter.Seq2[V, W]

Iterator is a wrapper around iter.Seq2 that allows for method chaining of most iterators found in this package.

func (Iterator2[V, W]) Drop 

func (iterator Iterator2[V, W]) Drop(count int) Iterator2[V, W]

Drop is a convenience method for chaining Drop on [Iterator2]s.

func (Iterator2[V, W]) Exclude 

func (iterator Iterator2[V, W]) Exclude(predicate func(V, W) bool) Iterator2[V, W]

Exclude is a convenience method for chaining Exclude on [Iterator2]s.

func (Iterator2[V, W]) Filter 

func (iterator Iterator2[V, W]) Filter(predicate func(V, W) bool) Iterator2[V, W]

Filter is a convenience method for chaining Filter on [Iterator2]s.

func (Iterator2[V, W]) ForEach 

func (iterator Iterator2[V, W]) ForEach(fn func(V, W))

ForEach is a convenience method for chaining ForEach on [Iterator2]s.

func (Iterator2[V, W]) Take 

func (iterator Iterator2[V, W]) Take(limit int) Iterator2[V, W]

Take is a convenience method for chaining Take on [Iterator2]s.

func (Iterator2[V, W]) Unzip 

func (iterator Iterator2[V, W]) Unzip() (Iterator[V], Iterator[W])

Unzip is a convenience method for chaining Unzip on [Iterator2]s.

Source Files

View all Source files

Directories

Path Synopsis
This package contains functions intended for use with [iter.Filter].
 This package contains functions intended for use with [iter.Filter].

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.