iter

package
v0.14.0 Latest Latest
Warning

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

 Go to latest Published: Aug 24, 2023 License: MIT Imports: 7 Imported by: 5

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Collect 

func Collect[T any](iter Iterator[T]) []T

Collect consumes an Iterator and returns all remaining items within a slice. It does not protect against infinite Iterators.

Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(iter.Collect[int](iter.Count().Take(3)))
}

Output:

[0 1 2]
Example (Method) 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(iter.Count().Take(3).Collect())
}

Output:

[0 1 2]

func Find added in v0.10.0 

func Find[T any](iter Iterator[T], predicate func(v T) bool) option.Option[T]

Find the first occurrence of a value that satisfies the predicate and return that value. If no value satisfies the predicate, return option.None.

Example 
package main

import (
	"fmt"

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

func main() {
	values := iter.Lift([]string{"foo", "bar", "baz"})
	bar := iter.Find[string](values, func(v string) bool { return v == "bar" })

	fmt.Println(bar)
}

Output:

Some(bar)
Example (Method) 
package main

import (
	"fmt"

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

func main() {
	bar := iter.Lift([]string{"foo", "bar", "baz"}).Find(func(v string) bool {
		return v == "bar"
	})

	fmt.Println(bar)
}

Output:

Some(bar)

func Fold added in v0.3.0 

func Fold[T any, U any](iter Iterator[T], initial U, biop func(U, T) U) U

Fold consumes an Iterator and returns the final result of applying the accumulator function to each element. The accumulator function accepts two arguments - an accumulator and an initial value and returns a new value for the next accumulation. Fold does not protect against infinite Iterators.

Example 
package main

import (
	"fmt"

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

func main() {
	sum := iter.Fold[int](iter.Count().Take(4), 0, ops.Add[int])

	fmt.Println(sum)
}

Output:

6

func ForEach added in v0.11.0 

func ForEach[T any](iter Iterator[T], callback func(T))

ForEach consumes an Iterator and executes callback function on each item.

Example 
package main

import (
	"fmt"

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

func main() {
	iter.ForEach[int](iter.Lift([]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/iter"
)

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

}

Output:

1
2
3

func ToChannel added in v0.6.0 

func ToChannel[T any](iter Iterator[T]) chan T

ToChannel consumes an Iterator and returns a channel that will receive all values from the provided Iterator. The channel is closed once the Iterator is exhausted.

Example 
package main

import (
	"fmt"

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

func main() {
	for number := range iter.ToChannel[int](iter.Lift([]int{1, 2, 3})) {
		fmt.Println(number)
	}

}

Output:

1
2
3

Types

type BaseIter added in v0.14.0 

type BaseIter[T any] struct {
	Iterator[T]
}

BaseIter is intended to be embeded in other iterators to expose method chaining.

func (*BaseIter[T]) Collect added in v0.14.0 

func (iter *BaseIter[T]) Collect() []T

Collect is a convenience method for Collect, providing this iterator as an argument.

func (*BaseIter[T]) Drop added in v0.14.0 

func (iter *BaseIter[T]) Drop(n uint) *DropIter[T]

Drop is a convenience method for Drop, providing this iterator as an argument.

func (*BaseIter[T]) Find added in v0.14.0 

func (iter *BaseIter[T]) Find(predicate func(T) bool) option.Option[T]

Find is a convenience method for Find, providing this iterator as an argument.

func (*BaseIter[T]) ForEach added in v0.14.0 

func (iter *BaseIter[T]) ForEach(callback func(T))

ForEach is a convenience method for ForEach, providing this iterator as an argument.

func (*BaseIter[T]) Take added in v0.14.0 

func (iter *BaseIter[T]) Take(n uint) *TakeIter[T]

Take is a convenience method for Take, providing this iterator as an argument.

type ChainIter added in v0.4.0 

type ChainIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

ChainIter iterator, see Chain.

func Chain added in v0.4.0 

func Chain[T any](iterators ...Iterator[T]) *ChainIter[T]

Chain instantiates a *ChainIter that will yield all items in the provided iterators to exhaustion first to last.

Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(iter.Chain[int](iter.Lift([]int{1, 2}), iter.Lift([]int{3, 4}), iter.Lift([]int{0, 9})).Collect())
}

Output:

[1 2 3 4 0 9]

func (*ChainIter[T]) Next added in v0.4.0 

func (iter *ChainIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type ChannelIter added in v0.6.0 

type ChannelIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

ChannelIter iterator, see FromChannel.

func FromChannel added in v0.6.0 

func FromChannel[T any](ch chan T) *ChannelIter[T]

FromChannel instantiates a *ChannelIter that will yield each value from the provided channel.

Example 
package main

import (
	"fmt"

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

func main() {
	ch := make(chan int, 2)

	go func() {
		ch <- 1
		ch <- 2
		close(ch)
	}()

	fmt.Println(iter.FromChannel(ch).Collect())
}

Output:

[1 2]

func (*ChannelIter[T]) Next added in v0.6.0 

func (iter *ChannelIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type CountIter 

type CountIter struct {
	BaseIter[int]
	// contains filtered or unexported fields
}

CountIter iterator, see Count.

func Count 

func Count() *CountIter

Count instantiates a *CountIter that will iterate over 0 and the natural numbers. Count is functionally "unlimited" although it does not protect against the integer limit.

Example 
package main

import (
	"fmt"

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

func main() {
	counter := iter.Count()
	fmt.Println(counter.Next())
	fmt.Println(counter.Next())
	fmt.Println(counter.Next())

}

Output:

Some(0)
Some(1)
Some(2)

func (*CountIter) Next 

func (c *CountIter) Next() option.Option[int]

Next implements the Iterator interface.

type CycleIter added in v0.12.0 

type CycleIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

CycleIter iterator, see Cycle.

func Cycle added in v0.12.0 

func Cycle[T any](iter Iterator[T]) *CycleIter[T]

Cycle instantiates a *CycleIter yielding all items from the provided iterator until exhaustion, and then yields them all over again on repeat.

Note that CycleIter stores the members from the underlying iterator so will grow in size as items are yielded until the underlying iterator is exhausted.

In most cases this iterator is infinite, except when the underlying iterator is exhausted before the first call to Next() in which case this iterator will always yield None.

Example 
package main

import (
	"fmt"

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

func main() {
	numbers := iter.Cycle[int](iter.Lift([]int{1, 2})).Take(5)
	fmt.Println(numbers.Collect())
}

Output:

[1 2 1 2 1]

func (*CycleIter[T]) Next added in v0.12.0 

func (iter *CycleIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type DropIter 

type DropIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

DropIter iterator, see Drop.

func Drop 

func Drop[T any](iter Iterator[T], count uint) *DropIter[T]

Drop instantiates a *DropIter that will skip the number of items of its wrapped iterator by the provided count.

Example 
package main

import (
	"fmt"

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

func main() {
	counter := iter.Drop[int](iter.Count(), 2)
	fmt.Println(counter.Next().Unwrap())
}

Output:

2
Example (Method) 
package main

import (
	"fmt"

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

func main() {
	counter := iter.Count().Drop(2)
	fmt.Println(counter.Next().Unwrap())
}

Output:

2

func (*DropIter[T]) Next 

func (iter *DropIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type ExhaustedIter 

type ExhaustedIter[T any] struct {
	BaseIter[T]
}

ExhaustedIter iterator, see Exhausted.

func Exhausted 

func Exhausted[T any]() *ExhaustedIter[T]

Exhausted instantiates an *ExhaustedIter that will immediately be exhausted (Next will always return a None variant).

Example 
package main

import (
	"fmt"

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

func main() {
	fmt.Println(iter.Exhausted[int]().Next())
}

Output:

None

func (*ExhaustedIter[T]) Next 

func (iter *ExhaustedIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type FilterIter 

type FilterIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

FilterIter iterator, see Filter.

func Exclude 

func Exclude[T any](iter Iterator[T], fun func(T) bool) *FilterIter[T]

Exclude instantiates a *FilterIter that selectively yields only results that cause the provided function to return `false`.

Example 
package main

import (
	"fmt"

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

func main() {
	filtered := iter.Exclude[int](iter.Lift([]int{0, 1, 0, 2}), filters.IsZero[int])
	fmt.Println(filtered.Next())
	fmt.Println(filtered.Next())
	fmt.Println(filtered.Next())

}

Output:

Some(1)
Some(2)
None

func Filter 

func Filter[T any](iter Iterator[T], fun func(T) bool) *FilterIter[T]

Filter instantiates a *FilterIter that selectively yields only results that cause the provided function to return `true`.

Example 
package main

import (
	"fmt"

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

func main() {
	filtered := iter.Filter[int](iter.Lift([]int{0, 1, 0, 2}), filters.IsZero[int])
	fmt.Println(filtered.Next())
	fmt.Println(filtered.Next())
	fmt.Println(filtered.Next())

}

Output:

Some(0)
Some(0)
None

func (*FilterIter[T]) Next 

func (iter *FilterIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type FilterMapIter added in v0.7.0 

type FilterMapIter[T any, U any] struct {
	BaseIter[U]
	// contains filtered or unexported fields
}

FilterMapIter iterator, see FilterMap.

func FilterMap added in v0.7.0 

func FilterMap[T any, U any](iter Iterator[T], fun func(T) option.Option[U]) *FilterMapIter[T, U]

FilterMap instantiates a *FilterMapIter that selectively yields only results that cause the provided function to return `true` with a map operation performed on them.

Example 
package main

import (
	"fmt"

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

func main() {
	selectAndTripleOdds := func(x int) option.Option[int] {
		if x%2 == 0 {
			return option.None[int]()
		}
		return option.Some(x * 3)
	}

	triples := iter.FilterMap[int](
		iter.Count().Take(6),
		selectAndTripleOdds,
	)

	fmt.Println(triples.Collect())
}

Output:

[3 9 15]

func (*FilterMapIter[T, U]) Next added in v0.7.0 

func (iter *FilterMapIter[T, U]) Next() option.Option[U]

Next implements the Iterator interface.

type Iterator 

type Iterator[T any] interface {
	Next() option.Option[T]
}

Iterator declares that each Iterator must implement a Next method. Successive calls to the next method shall return the next item in the Iterator, wrapped in an option.Some variant.

Exhausted Iterators shall return a option.None variant on every subsequent call.

type LiftHashMapIter added in v0.8.0 

type LiftHashMapIter[T comparable, U any] struct {
	BaseIter[Tuple[T, U]]
	// contains filtered or unexported fields
}

LiftHashMapIter iterator, see LiftHashMap.

func LiftHashMap added in v0.8.0 

func LiftHashMap[T comparable, U any](hashmap map[T]U) *LiftHashMapIter[T, U]

LiftHashMap instantiates a *LiftHashMapIter that will yield all items in the provided map as a Tuple.

Unlike most iterators, LiftHashMap should be closed after usage (because range order is non-deterministic and the iterator needs to preserve its progress). This restriction may be removed if/when Go has a "yield" keyword.

The iterator is closed when any of the two conditions are met.

1. The caller explicitly invokes the `Close` method. 2. The iterator is exhausted.

It is safe to call Close multiple times or after exhaustion. It is not necessary to call Close if exhaustion is guaranteed, but may be wise to redundantly call Close if you're unsure.

func (*LiftHashMapIter[T, U]) Close added in v0.8.0 

func (iter *LiftHashMapIter[T, U]) Close() error

Close the iterator. See LiftHashMap's documentation for details.

This function implements the io.Closer interface.

This function can never fail and the error can be ignored.

func (*LiftHashMapIter[T, U]) Next added in v0.8.0 

func (iter *LiftHashMapIter[T, U]) Next() option.Option[Tuple[T, U]]

Next implements the Iterator interface.

type LiftHashMapKeysIter added in v0.8.0 

type LiftHashMapKeysIter[T comparable, U any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

LiftHashMapKeysIter iterator, see LiftHashMapKeys.

func LiftHashMapKeys added in v0.8.0 

func LiftHashMapKeys[T comparable, U any](hashmap map[T]U) *LiftHashMapKeysIter[T, U]

LiftHashMapKeys instantiates a *LiftHashMapKeysIter that will yield all keys in the provided map.

See LiftHashMap for information on closing this iterator.

func (*LiftHashMapKeysIter[T, U]) Close added in v0.8.0 

func (iter *LiftHashMapKeysIter[T, U]) Close() error

Close the iterator. See LiftHashMap's documentation for details.

This function implements the io.Closer interface.

This function can never fail and the error can be ignored.

func (*LiftHashMapKeysIter[T, U]) Next added in v0.8.0 

func (iter *LiftHashMapKeysIter[T, U]) Next() option.Option[T]

Next implements the Iterator interface.

type LiftHashMapValuesIter added in v0.8.0 

type LiftHashMapValuesIter[T comparable, U any] struct {
	BaseIter[U]
	// contains filtered or unexported fields
}

LiftHashMapValuesIter iterator, see LiftHashMapValues.

func LiftHashMapValues added in v0.8.0 

func LiftHashMapValues[T comparable, U any](hashmap map[T]U) *LiftHashMapValuesIter[T, U]

LiftHashMapValues instantiates a *LiftHashMapValuesIter that will yield all keys in the provided map.

See LiftHashMap for information on closing this iterator.

func (*LiftHashMapValuesIter[T, U]) Close added in v0.8.0 

func (iter *LiftHashMapValuesIter[T, U]) Close() error

Close the iterator. See LiftHashMap's documentation for details.

This function implements the io.Closer interface.

This function can never fail and the error can be ignored.

func (*LiftHashMapValuesIter[T, U]) Next added in v0.8.0 

func (iter *LiftHashMapValuesIter[T, U]) Next() option.Option[U]

Next implements the Iterator interface.

type LiftIter 

type LiftIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

LiftIter iterator, see Lift.

func Lift 

func Lift[T any](items []T) *LiftIter[T]

Lift instantiates a *LiftIter that will yield all items in the provided slice.

Example 
package main

import (
	"fmt"

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

func main() {
	positives := iter.Filter[int](iter.Lift([]int{-1, 4, 6, 4, -5}), filters.GreaterThan(-1))
	fmt.Println(positives.Collect())
}

Output:

[4 6 4]

func (*LiftIter[T]) Next 

func (iter *LiftIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type LinesIter 

type LinesIter struct {
	BaseIter[result.Result[[]byte]]
	// contains filtered or unexported fields
}

LinesIter iterator, see Lines.

func Lines 

func Lines(r io.Reader) *LinesIter

Lines instantiates a *LinesIter that will yield each line from the provided io.Reader.

Be aware that since Read operations can fail, the result time of each item is wrapped in a result.Result.

Example 
package main

import (
	"bytes"
	"fmt"

	"github.com/BooleanCat/go-functional/iter"
	"github.com/BooleanCat/go-functional/iter/ops"
	"github.com/BooleanCat/go-functional/result"
)

func main() {
	lines := iter.Lines(bytes.NewBufferString("hello\nthere"))
	unwrapped := iter.Map[result.Result[[]byte]](lines, ops.UnwrapResult[[]byte])

	fmt.Println(unwrapped.Collect())
}

Output:

[[104 101 108 108 111] [116 104 101 114 101]]

func (*LinesIter) Next 

func (iter *LinesIter) Next() option.Option[result.Result[[]byte]]

Next implements the Iterator interface.

type MapIter 

type MapIter[T, U any] struct {
	BaseIter[U]
	// contains filtered or unexported fields
}

MapIter iterator, see Map.

func LinesString 

func LinesString(r io.Reader) *MapIter[result.Result[[]byte], result.Result[string]]

LinesString instantiates a *LinesIter with results converted to a string via a *MapIter. See Lines for more information.

Example 
package main

import (
	"bytes"
	"fmt"

	"github.com/BooleanCat/go-functional/iter"
	"github.com/BooleanCat/go-functional/iter/ops"
	"github.com/BooleanCat/go-functional/result"
)

func main() {
	lines := iter.LinesString(bytes.NewBufferString("hello\nthere"))
	unwrapped := iter.Map[result.Result[string]](lines, ops.UnwrapResult[string])

	fmt.Println(unwrapped.Collect())
}

Output:

[hello there]

func Map 

func Map[T, U any](iter Iterator[T], f func(T) U) *MapIter[T, U]

Map instantiates a *MapIter that will apply the provided function to each item yielded by the provided Iterator.

Example 
package main

import (
	"fmt"

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

func main() {
	double := func(a int) int { return a * 2 }
	items := iter.Map[int](iter.Lift([]int{0, 1, 2, 3}), double).Collect()

	fmt.Println(items)
}

Output:

[0 2 4 6]

func (*MapIter[T, U]) Next 

func (iter *MapIter[T, U]) Next() option.Option[U]

Next implements the Iterator interface.

type RepeatIter added in v0.12.0 

type RepeatIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

RepeatIter iterator, see Repeat.

func Repeat added in v0.12.0 

func Repeat[T any](item T) *RepeatIter[T]

Repeat instantiates a *RepeatIter always yield the provided item.

This iterator will never be exhausted.

Example 
package main

import (
	"fmt"

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

func main() {
	iter := iter.Repeat[int](42)
	fmt.Println(iter.Next())
	fmt.Println(iter.Next())
}

Output:

Some(42)
Some(42)

func (*RepeatIter[T]) Next added in v0.12.0 

func (iter *RepeatIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type TakeIter 

type TakeIter[T any] struct {
	BaseIter[T]
	// contains filtered or unexported fields
}

TakeIter iterator, see Take.

func Take 

func Take[T any](iter Iterator[T], limit uint) *TakeIter[T]

Take instantiates a *TakeIter that will limit the number of items of its wrapped iterator to a maximum limit.

Example 
package main

import (
	"fmt"

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

func main() {
	iter := iter.Take[int](iter.Count(), 2)
	fmt.Println(iter.Next())
	fmt.Println(iter.Next())
	fmt.Println(iter.Next())
}

Output:

Some(0)
Some(1)
None
Example (Method) 
package main

import (
	"fmt"

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

func main() {
	iter := iter.Count().Take(2)
	fmt.Println(iter.Next())
	fmt.Println(iter.Next())
	fmt.Println(iter.Next())
}

Output:

Some(0)
Some(1)
None

func (*TakeIter[T]) Next 

func (iter *TakeIter[T]) Next() option.Option[T]

Next implements the Iterator interface.

type Tuple 

type Tuple[T, U any] struct {
	One T
	Two U
}

Tuples are pairs of values.

type ZipIter 

type ZipIter[T, U any] struct {
	BaseIter[Tuple[T, U]]
	// contains filtered or unexported fields
}

ZipIter iterator, see Zip.

func Zip 

func Zip[T, U any](iter1 Iterator[T], iter2 Iterator[U]) *ZipIter[T, U]

Zip instantiates a *ZipIter yielding a Tuple containing the result of a call to each provided Iterator's Next. This iterator is exhausted when one of the provided iterators is exhausted.

Example 
package main

import (
	"fmt"

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

func main() {
	evens := iter.Filter[int](iter.Count(), filters.IsEven[int])
	odds := iter.Filter[int](iter.Count(), filters.IsOdd[int])

	fmt.Println(iter.Zip[int, int](evens, odds).Take(3).Collect())
}

Output:

[{0 1} {2 3} {4 5}]

func (*ZipIter[T, U]) Next 

func (iter *ZipIter[T, U]) Next() option.Option[Tuple[T, U]]

Next implements the Iterator interface.

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].
This package contains functions intended for use with [iter.Fold] and [iter.Map].
 This package contains functions intended for use with [iter.Fold] and [iter.Map].

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.