Documentation ¶
Index ¶
- func Collect[T any](iter Iterator[T]) []T
- func CollectResults[T any](iter Iterator[result.Result[T]]) result.Result[[]T]
- func Find[T any](iter Iterator[T], predicate func(v T) bool) option.Option[T]
- func Fold[T any, U any](iter Iterator[T], initial U, biop func(U, T) U) U
- func ForEach[T any](iter Iterator[T], callback func(T))
- func ToChannel[T any](iter Iterator[T]) chan T
- type BaseIter
- func (iter *BaseIter[T]) Chain(iterators ...Iterator[T]) *ChainIter[T]
- func (iter *BaseIter[T]) Collect() []T
- func (iter *BaseIter[T]) Drop(n uint) *DropIter[T]
- func (iter *BaseIter[T]) Enumerate() *EnumerateIter[T]
- func (iter *BaseIter[T]) Exclude(fun func(T) bool) *FilterIter[T]
- func (iter *BaseIter[T]) Filter(fun func(T) bool) *FilterIter[T]
- func (iter *BaseIter[T]) FilterMap(fun func(T) option.Option[T]) *FilterMapIter[T, T]
- func (iter *BaseIter[T]) Find(predicate func(T) bool) option.Option[T]
- func (iter *BaseIter[T]) ForEach(callback func(T))
- func (iter *BaseIter[T]) Take(n uint) *TakeIter[T]
- func (iter *BaseIter[T]) ToChannel() chan T
- func (iter *BaseIter[T]) Transform(op func(T) T) *MapIter[T, T]
- type ChainIter
- type ChannelIter
- type CountIter
- type CycleIter
- type DropIter
- type EnumerateIter
- type ExhaustedIter
- type FilterIter
- type FilterMapIter
- type Iterator
- type LiftHashMapIter
- type LiftHashMapKeysIter
- type LiftHashMapValuesIter
- type LiftIter
- type LinesIter
- type LinesStringIter
- type MapIter
- type Pair
- type RepeatIter
- type RunesIter
- type TakeIter
- type ZipIter
Examples ¶
- Chain
- Chain (Method)
- ChainIter.String
- ChannelIter.String
- Collect
- Collect (Method)
- CollectResults
- Count
- CountIter.String
- Cycle
- CycleIter.String
- Drop
- Drop (Method)
- DropIter.String
- Enumerate
- Enumerate (Method)
- EnumerateIter.String
- Exclude
- Exclude (Method)
- Exhausted
- ExhaustedIter.String
- Filter
- Filter (Method)
- FilterIter.String
- FilterMap
- FilterMap (Method)
- FilterMapIter.String
- Find
- Find (Method)
- Fold
- ForEach
- ForEach (Method)
- FromChannel
- Lift
- LiftHashMap
- LiftHashMapIter.String
- LiftHashMapKeys
- LiftHashMapKeysIter.String
- LiftHashMapValues
- LiftIter.String
- Lines
- LinesIter.String
- LinesString
- LinesStringIter.String
- Map
- MapIter.String
- Repeat
- RepeatIter.String
- Runes
- Runes (Slice)
- RunesIter.String
- Take
- Take (Method)
- TakeIter.String
- ToChannel
- ToChannel (Method)
- Transform
- Transform (Method)
- Zip
- ZipIter.String
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Collect ¶
Collect consumes an Iterator and returns all 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 CollectResults ¶ added in v0.16.0
CollectResults consumes an Iterator with a yield type of result.Result. It returns all items as a slice. It does not protect against infinite iterators.
When a result.Err is encountered, collection stops and the result.Err is returned immediately.
Example ¶
package main import ( "bytes" "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { words := iter.CollectResults[string](iter.LinesString(bytes.NewBufferString("hello\nfriend"))) fmt.Println(words) }
Output: Ok([hello friend])
func Find ¶ added in v0.10.0
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
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.
Unlike other Iterator consumers (e.g. Collect), it is not possible to call Fold as a method on iterators defined in this package. This is due to a limitation of Go's type system; new type parameters cannot be defined on methods.
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
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
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
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { for number := range iter.Lift([]int{1, 2, 3}).ToChannel() { fmt.Println(number) } }
Output: 1 2 3
Types ¶
type BaseIter ¶ added in v0.14.0
BaseIter is intended to be embedded in other iterators to expose method chaining.
func (*BaseIter[T]) Chain ¶ added in v0.15.0
Chain is a convenience method for Chain, providing this iterator as an argument.
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
Drop is a convenience method for Drop, providing this iterator as an argument.
func (*BaseIter[T]) Enumerate ¶ added in v0.16.0
func (iter *BaseIter[T]) Enumerate() *EnumerateIter[T]
Enumerate is a convenience method for Enumerate, providing this iterator as an argument.
func (*BaseIter[T]) Exclude ¶ added in v0.16.0
func (iter *BaseIter[T]) Exclude(fun func(T) bool) *FilterIter[T]
Exclude is a convenience method for Exclude, providing this iterator as an argument.
func (*BaseIter[T]) Filter ¶ added in v0.15.0
func (iter *BaseIter[T]) Filter(fun func(T) bool) *FilterIter[T]
Filter is a convenience method for Filter, providing this iterator as an argument.
func (*BaseIter[T]) FilterMap ¶ added in v1.1.0
func (iter *BaseIter[T]) FilterMap(fun func(T) option.Option[T]) *FilterMapIter[T, T]
FilterMap is a convenience method for FilterMap, providing this iterator as an argument.
func (*BaseIter[T]) Find ¶ added in v0.14.0
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
Take is a convenience method for Take, providing this iterator as an argument.
type ChainIter ¶ added in v0.4.0
ChainIter iterator, see Chain.
func Chain ¶ added in v0.4.0
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]
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Lift([]int{1, 2}).Chain(iter.Lift([]int{3, 4}), iter.Lift([]int{0, 9})).Collect()) }
Output: [1 2 3 4 0 9]
type ChannelIter ¶ added in v0.6.0
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.
func (ChannelIter[T]) String ¶ added in v1.1.0
func (iter ChannelIter[T]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { ch := make(chan int, 2) close(ch) fmt.Println(iter.FromChannel(ch)) }
Output: Iterator<Channel, type=int>
type CountIter ¶
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)
type CycleIter ¶ added in v0.12.0
CycleIter iterator, see Cycle.
func Cycle ¶ added in v0.12.0
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]) String ¶ added in v1.1.0
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Cycle[int](iter.Lift([]int{1, 2}))) }
Output: Iterator<Cycle, type=int>
type DropIter ¶
DropIter iterator, see Drop.
func Drop ¶
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]) String ¶ added in v1.1.0
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Drop[int](iter.Count(), 2)) }
Output: Iterator<Drop, type=int>
type EnumerateIter ¶ added in v0.16.0
EnumerateIter iterator, see Enumerate.
func Enumerate ¶ added in v0.16.0
func Enumerate[T any](iterator Iterator[T]) *EnumerateIter[T]
Drop instantiates an *EnumerateIter that yield Pairs of the index of iteration and values for a given iterator.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { iterator := iter.Enumerate[string](iter.Lift([]string{"Hello", "Friend"})) fmt.Println(iterator.Next()) fmt.Println(iterator.Next()) fmt.Println(iterator.Next()) }
Output: Some((0, Hello)) Some((1, Friend)) None
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { iterator := iter.Lift([]string{"Hello", "Friend"}).Enumerate() fmt.Println(iterator.Next()) fmt.Println(iterator.Next()) fmt.Println(iterator.Next()) }
Output: Some((0, Hello)) Some((1, Friend)) None
func (*EnumerateIter[T]) Next ¶ added in v0.16.0
func (iter *EnumerateIter[T]) Next() option.Option[Pair[uint, T]]
Next implements the Iterator interface.
func (EnumerateIter[T]) String ¶ added in v1.1.0
func (iter EnumerateIter[T]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Enumerate[string](iter.Exhausted[string]())) }
Output: Iterator<Enumerate, type=Pair<uint, string>>
type ExhaustedIter ¶
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.
func (ExhaustedIter[T]) String ¶ added in v1.1.0
func (iter ExhaustedIter[T]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Exhausted[int]()) }
Output: Iterator<Exhausted, type=int>
type FilterIter ¶
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
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" "github.com/BooleanCat/go-functional/iter/filters" ) func main() { filtered := iter.Lift([]int{0, 1, 0, 2}).Exclude(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
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" "github.com/BooleanCat/go-functional/iter/filters" ) func main() { filtered := iter.Lift([]int{0, 1, 0, 2}).Filter(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.
func (FilterIter[T]) String ¶ added in v1.1.0
func (iter FilterIter[T]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" "github.com/BooleanCat/go-functional/iter/filters" ) func main() { fmt.Println(iter.Filter[int](iter.Exhausted[int](), filters.IsZero[int])) }
Output: Iterator<Filter, type=int>
type FilterMapIter ¶ added in v0.7.0
FilterMapIter iterator, see FilterMap.
func FilterMap ¶ added in v0.7.0
FilterMap instantiates a *FilterMapIter that selectively yields only results that cause the provided function to return `true` with a map operation performed on them.
Unlike other iterators (e.g. Filter), it is not possible to call FilterMap as a method on iterators defined in this package. This is due to a limitation of Go's type system; new type parameters cannot be defined on methods.
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]
Example (Method) ¶
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.Count().Take(6).FilterMap(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.
func (FilterMapIter[T, U]) String ¶ added in v1.1.0
func (iter FilterMapIter[T, U]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" "github.com/BooleanCat/go-functional/option" ) func main() { fmt.Println(iter.FilterMap[int](iter.Exhausted[int](), func(_ int) option.Option[int] { return option.Some(42) })) }
Output: Iterator<FilterMap, type=int>
type Iterator ¶
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[Pair[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 Pair.
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.
Example ¶
package main import ( "fmt" "sort" "github.com/BooleanCat/go-functional/iter" ) func main() { pokemon := make(map[string]string) pokemon["name"] = "pikachu" pokemon["type"] = "electric" items := iter.LiftHashMap(pokemon).Collect() sort.Slice(items, func(i, j int) bool { return items[i].One < items[j].One }) fmt.Println(items) }
Output: [(name, pikachu) (type, electric)]
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[Pair[T, U]]
Next implements the Iterator interface.
func (LiftHashMapIter[T, U]) String ¶ added in v1.1.0
func (iter LiftHashMapIter[T, U]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.LiftHashMap(make(map[string]string))) }
Output: Iterator<LiftHashMap, type=Pair<string, string>>
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.
Example ¶
package main import ( "fmt" "sort" "github.com/BooleanCat/go-functional/iter" ) func main() { pokemon := make(map[string]string) pokemon["name"] = "pikachu" pokemon["type"] = "electric" keys := iter.LiftHashMapKeys(pokemon).Collect() sort.Strings(keys) fmt.Println(keys) }
Output: [name type]
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.
func (LiftHashMapKeysIter[T, U]) String ¶ added in v1.1.0
func (iter LiftHashMapKeysIter[T, U]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.LiftHashMapKeys(make(map[string]int))) }
Output: Iterator<LiftHashMapKeys, type=string>
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.
Example ¶
package main import ( "fmt" "sort" "github.com/BooleanCat/go-functional/iter" ) func main() { pokemon := make(map[string]string) pokemon["name"] = "pikachu" pokemon["type"] = "electric" values := iter.LiftHashMapValues(pokemon).Collect() sort.Strings(values) fmt.Println(values) }
Output: [electric pikachu]
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.
func (LiftHashMapValuesIter[T, U]) String ¶ added in v1.1.0
func (iter LiftHashMapValuesIter[T, U]) String() string
String implements the fmt.Stringer interface
type LiftIter ¶
LiftIter iterator, see Lift.
func Lift ¶
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]
type LinesIter ¶
LinesIter iterator, see Lines.
func Lines ¶
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) CollectResults ¶ added in v0.18.0
CollectResults is a convenience method for CollectResults, providing this iterator as an argument.
func (LinesIter) String ¶ added in v1.1.0
String implements the fmt.Stringer interface
Example ¶
package main import ( "bytes" "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Lines(bytes.NewBufferString("hello\nthere"))) }
Output: Iterator<Lines, type=Result<[]byte>>
type LinesStringIter ¶ added in v0.18.0
type LinesStringIter struct { BaseIter[result.Result[string]] // contains filtered or unexported fields }
func LinesString ¶
func LinesString(r io.Reader) *LinesStringIter
LinesString instantiates a *LinesStringIter that behaves like a *LinesIter except that it yields strings. See LinesIter.
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 (*LinesStringIter) CollectResults ¶ added in v0.18.0
func (iter *LinesStringIter) CollectResults() result.Result[[]string]
CollectResults is a convenience method for CollectResults, providing this iterator as an argument.
func (LinesStringIter) String ¶ added in v1.1.0
func (iter LinesStringIter) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "bytes" "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.LinesString(bytes.NewBufferString("hello\nthere"))) }
Output: Iterator<LinesString, type=Result<string>>
type MapIter ¶
MapIter iterator, see Map.
func Map ¶
Map instantiates a *MapIter that will apply the provided function to each item yielded by the provided Iterator.
Unlike other iterators (e.g. Filter), it is not possible to call Map as a method on iterators defined in this package. This is due to a limitation of Go's type system; new type parameters cannot be defined on methods.
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 Transform ¶ added in v0.16.0
Transform instantiates a *MapIter that will apply the provided function to each item yielded by the provided Iterator.
Transform is a special case of Map where the argument and returned value for the operation are of the same type. This makes it possible to call Transform as a method on other iterators.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { addTwo := func(number int) int { return number + 2 } numbers := iter.Transform[int](iter.Count(), addTwo).Take(3).Collect() fmt.Println(numbers) }
Output: [2 3 4]
Example (Method) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { addTwo := func(number int) int { return number + 2 } numbers := iter.Count().Transform(addTwo).Take(3).Collect() fmt.Println(numbers) }
Output: [2 3 4]
func (MapIter[T, U]) String ¶ added in v1.0.0
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "strconv" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Map[int, string](iter.Count(), strconv.Itoa)) }
Output: Iterator<Map, type=string>
type RepeatIter ¶ added in v0.12.0
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.
func (RepeatIter[T]) String ¶ added in v1.1.0
func (iter RepeatIter[T]) String() string
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Repeat[int](42)) }
Output: Iterator<Repeat, type=int>
type RunesIter ¶ added in v0.17.0
RunesIter iterator, see Runes.
func Runes ¶ added in v0.17.0
Runes instantiates a *RunesIter that will yield a rune on iteration.
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { runes := iter.Runes("Hello, 世界!").Collect() fmt.Println(string(runes[7:9])) }
Output: 世界
Example (Slice) ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { runes := iter.Runes([]rune("Hello, 世界!")).Collect() fmt.Println(string(runes[7:9])) }
Output: 世界
type TakeIter ¶
TakeIter iterator, see Take.
func Take ¶
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]) String ¶ added in v1.1.0
String implements the fmt.Stringer interface
Example ¶
package main import ( "fmt" "github.com/BooleanCat/go-functional/iter" ) func main() { fmt.Println(iter.Take[int](iter.Count(), 2)) }
Output: Iterator<Take, type=int>
type ZipIter ¶
ZipIter iterator, see Zip.
func Zip ¶
Zip instantiates a *ZipIter yielding a Pair 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]) String ¶ added in v1.1.0
String implements the fmt.Stringer interface
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)) }
Output: Iterator<Zip, type=Pair<int, int>>
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] / [iter.Transform].
|
This package contains functions intended for use with [iter.Fold] and [iter.Map] / [iter.Transform]. |