The highest tagged major version is
Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Collect ¶
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() {
numbers := iter.Collect[int](iter.Take[int](iter.Count(), 3))
fmt.Println(numbers)
}
Output: [0 1 2]
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 element and returns a new accumulator. The initial value is the accumulator for the first call. 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.Take[int](iter.Count(), 4), 0, ops.Add[int])
fmt.Println(sum)
}
Output: 6
Types ¶
type ChainIter ¶ added in v0.4.0
type ChainIter[T any] struct { // contains filtered or unexported fields }
ChainIter implements `Chain`. See `Chain`'s documentation.
func Chain ¶ added in v0.4.0
Chain instantiates a `ChainIter` that will yield all items in the provided iterators to exhaustion, from left to right.
Example ¶
package main
import (
"fmt"
"github.com/BooleanCat/go-functional/iter"
)
func main() {
fmt.Println(iter.Collect[int](iter.Chain[int](iter.Lift([]int{1, 2}), iter.Lift([]int{3, 4}), iter.Lift([]int{0, 9}))))
}
Output: [1 2 3 4 0 9]
type CountIter ¶
type CountIter struct {
// contains filtered or unexported fields
}
CountIter implements `Count`. See `Count`'s documentation.
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 DropIter ¶
type DropIter[T any] struct { // contains filtered or unexported fields }
DropIter implements `Drop`. See `Drop`'s documentation.
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
type ExhaustedIter ¶
type ExhaustedIter[T any] struct{}
ExhaustedIter implements `Exhausted`. See `Exhausted`'s documentation.
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 for `ExhaustedIter`.
type FilterIter ¶
type FilterIter[T any] struct { // contains filtered or unexported fields }
FilterIter implements `Filter`. See `Filter`'s documentation.
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 for `Filter`.
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 `None` variant of `Option` on every subsequent call.
type LiftIter ¶
type LiftIter[T any] struct { // contains filtered or unexported fields }
LiftIter implements `Lift`. See `Lift`'s documentation.
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(iter.Collect[int](positives))
}
Output: [4 6 4]
type LinesIter ¶
type LinesIter struct {
// contains filtered or unexported fields
}
LinesIter implements `Lines`. See `Lines`' documentation.
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 `result.Result[[]byte]`. Errors will need to be handled as a failure is wrapped in an Ok variant. Multiple calls to `Next()` may simply repeat the same error and cause an infinite loop when collected.
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(iter.Collect[[]byte](unwrapped))
}
Output: [[104 101 108 108 111] [116 104 101 114 101]]
type MapIter ¶
type MapIter[T, U any] struct { // contains filtered or unexported fields }
MapIter implements `Map`. See `Map`'s documentation.
func LinesString ¶
LinesString instantiates a `LinesIter` with results converted to a string via a MapIter. See `Lines` documentation 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(iter.Collect[string](unwrapped))
}
Output: [hello there]
func Map ¶
Take 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.Collect[int](iter.Map[int](iter.Lift([]int{0, 1, 2, 3}), double))
fmt.Println(items)
}
Output: [0 2 4 6]
type TakeIter ¶
type TakeIter[T any] struct { // contains filtered or unexported fields }
TakeIter implements `Take`. See `Take`'s documentation.
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
type ZipIter ¶
type ZipIter[T, U any] struct { // contains filtered or unexported fields }
ZipIter implements `Zip`. See `Zip`'s documentation.
func Zip ¶
Zip instantiates a `Zip` yield `Tuples` containing the result of a call to each provided Iterator's `Next`. The Iterator is exhausted when one of the provided Iterators is exhausted.
Example ¶
package main
import (
"fmt"
"github.com/BooleanCat/go-functional/iter"
)
func main() {
isEven := func(a int) bool { return a%2 == 0 }
evens := iter.Filter[int](iter.Count(), isEven)
odds := iter.Exclude[int](iter.Count(), isEven)
zipped := iter.Collect[iter.Tuple[int, int]](
iter.Take[iter.Tuple[int, int]](iter.Zip[int, int](evens, odds), 3),
)
fmt.Println(zipped)
}
Output: [{0 1} {2 3} {4 5}]
Source Files
Directories