enumerator

enumerator

The lazy sequence composite of go-composites, in the spirit of Ruby's Enumerator::Lazy. Transforms are lazy — they wrap a producer and evaluate nothing until a terminal operation pulls items through — so you can take a finite prefix of an infinite source without it ever running away.

Install

go get github.com/go-composites/enumerator

API

import Enumerator "github.com/go-composites/enumerator/src"

type Interface interface {
    // Lazy transforms — return a new Enumerator, evaluate nothing.
    Map(fn func(interface{}) interface{}) Interface
    Filter(pred func(interface{}) bool) Interface
    Take(n int) Interface
    // Terminal operations — force evaluation.
    ToArray() Array.Interface
    Each(fn func(interface{}) Result.Interface) Result.Interface
    First() Result.Interface
    Reduce(seed interface{}, fn func(acc, item interface{}) Result.Interface) Result.Interface
    IsNull() bool
}

func New(items ...interface{}) Interface                                   // finite source
func Generate(seed interface{}, fn func(interface{}) interface{}) Interface // infinite source
func Null() Interface                                                       // Null-Object

// A finite prefix of an infinite sequence — lazily.
squares := Enumerator.
    Generate(1, func(x interface{}) interface{} { return x.(int) + 1 }).
    Map(func(x interface{}) interface{} { return x.(int) * x.(int) }).
    Take(3).
    ToArray() // [1 4 9]

Null() is the never-nil empty sequence: transforms return it, ToArray is empty, First errors, Each/Reduce are no-op successes, and IsNull() is true.

Dependencies

enumerator depends on array (for ToArray), result and error, and transitively on null.

License

BSD-3-Clause © the go-composites/enumerator authors.