iterkit

src := iterkit.IntRange(0, 1000)

batched := iterkit.Batch(src)

for vs := range batched {
	fmt.Printf("%#v\n", vs)
}

src := iterkit.IntRange(0, 1000)

batched := iterkit.Batch(src, iterkit.BatchSize(100))

for vs := range batched {
	fmt.Printf("%#v\n", vs)
}

slowIterSeq := iterkit.IntRange(0, 1000)

batched := iterkit.Batch(slowIterSeq, iterkit.BatchWaitLimit(time.Second))

// Batching will occure either when the batching size reached
// or when the wait limit duration passed
for vs := range batched {
	fmt.Printf("%#v\n", vs)
}

ch := make(chan int)

i := iterkit.Chan(ch)

go func() {
	defer close(ch)
	ch <- 42
}()

for v := range i {
	fmt.Println(v) // 42 once
}

for char := range iterkit.CharRange('A', 'Z') {
	// prints characters between A and Z
	// A, B, C, D... Z
	fmt.Println(string(char))
}

var itr iter.Seq[int]

ints := iterkit.Collect(itr)
_ = ints

var itr iter.Seq2[string, int]

type T struct {
	S string
	I int
}

ints := iterkit.Collect2(itr, func(s string, i int) T {
	return T{S: s, I: i}
})
_ = ints

var values iter.Seq2[string, int] = func(yield func(string, int) bool) {
	if !yield("foo", 42) {
		return
	}
	if !yield("bar", 7) {
		return
	}
	if !yield("baz", 13) {
		return
	}
}

vs := iterkit.Collect2Map(values)

_ = vs // map[string]int{"foo": 42, "bar": 7, "baz": 13}

var itr iter.Seq2[int, error] = func(yield func(int, error) bool) {
	for i := 0; i < 42; i++ {
		if !yield(i, nil) {
			return
		}
	}
}

vs, err := iterkit.CollectE(itr)
_, _ = vs, err

var itr iter.Seq2[int, error] = iterkit.ToSeqE(iterkit.IntRange(1, 10))
vs, err := iterkit.CollectEPull(iter.Pull2(itr))
_ = vs
_ = err

var itr iter.Seq[int] = iterkit.IntRange(1, 10)
vs := iterkit.CollectPull(iter.Pull(itr))
_ = vs

i := iterkit.Slice1[int]([]int{1, 2, 3})
total := iterkit.Count[int](i)
_ = total // 3

itr := maps.All(map[string]int{
	"foo": 2,
	"bar": 4,
	"baz": 8,
})
iterkit.Count2(itr) // 3

i := iterkit.SliceE([]int{1, 2, 3})

n, err := iterkit.CountE(i)
_, _ = n, err

_ = iterkit.Empty[any]()

var i iter.Seq[int]
i = iterkit.Slice1([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
i = iterkit.Filter[int](i, func(n int) bool { return n > 2 })

for v := range i {
	fmt.Println(v)
}

numbers := iterkit.IntRangeE(1, 100)
evens := iterkit.Filter(numbers, func(n int) bool {
	return n%2 == 0
})

_ = evens

var itr iter.Seq2[string, int] = func(yield func(string, int) bool) {
	for i := 0; i < 42; i++ {
		if !yield(strconv.Itoa(i), i) {
			return
		}
	}
}

k, v, ok := iterkit.First2(itr)
_, _, _ = k, v, ok

var itr iter.Seq2[string, error] = func(yield func(string, error) bool) {
	for i := 0; i < 42; i++ {
		if !yield(strconv.Itoa(i), nil) {
			return
		}
	}
}

v, ok, err := iterkit.FirstE(itr)
_, _, _ = v, ok, err

inf42 := func(yield func(int) bool) {
	for /* infinite */ {
		if !yield(42) {
			return
		}
	}
}

i := iterkit.Head[int](inf42, 3)

vs := iterkit.Collect(i)
_ = vs // []{42, 42, 42}, nil

inf42 := func(yield func(int, int) bool) {
	for /* infinite */ {
		if !yield(42, 24) {
			return
		}
	}
}

i := iterkit.Head2[int](inf42, 3)

vs := iterkit.Collect2Map(i)
_ = vs // map[int]int{42:24, 42:24, 42:24}, nil

for n := range iterkit.IntRange(1, 9) {
	// prints characters between 1 and 9
	// 1, 2, 3, 4, 5, 6, 7, 8, 9
	fmt.Println(n)
}

itr := iterkit.IntRange(0, 10)

n, ok := iterkit.Last(itr)
_ = ok // true
_ = n  // 10

var itr iter.Seq2[int, string] = func(yield func(int, string) bool) {
	for n := range iterkit.IntRange(0, 10) {
		if !yield(n, strconv.Itoa(n)) {
			return
		}
	}
}

num, str, ok := iterkit.Last2(itr)
_ = ok  // true
_ = num // 10
_ = str // "10"

itr := iterkit.IntRangeE(0, 10)

n, ok, err := iterkit.LastE(itr)
_ = err // nil
_ = ok  // true
_ = n   // 10

rawNumbers := iterkit.Slice1([]string{"1", "2", "42"})
numbers := iterkit.Map[int](rawNumbers, func(v string) int {
	return len(v)
})
_ = numbers

itr := maps.All(map[int]string{1: "1", 2: "2", 3: "42"})

numbers := iterkit.Map2[int, int](itr, func(k int, v string) (int, int) {
	return k, len(v)
})

_ = numbers

_ = iterkit.OffsetE(iterkit.IntRangeE(2, 6), 2)

_ = iterkit.Offset2(iterkit.IntRangeE(2, 6), 2)

raw := iterkit.Slice1([]int{1, 2, 42})

_, _ = iterkit.Reduce(raw, nil, func(vs []int, v int) []int {
	return append(vs, v)
})

raw := iterkit.Slice1([]int{1, 2, 42})

_ = iterkit.Reduce1[[]int](raw, nil, func(vs []int, v int) []int {
	return append(vs, v)
})

raw := iterkit.SliceE([]int{1, 2, 42})

_, _ = iterkit.ReduceE(raw, nil, func(vs []int, v int) []int {
	return append(vs, v)
})

raw := iterkit.Slice1([]string{"1", "2", "42"})

_, _ = iterkit.ReduceErr[[]int](raw, nil, func(vs []int, raw string) ([]int, error) {

	v, err := strconv.Atoi(raw)
	if err != nil {
		return nil, err
	}
	return append(vs, v), nil

})

var sourceSeqE iter.Seq2[int, error]

i, errFunc := iterkit.SplitSeqE(sourceSeqE)
for v := range i {
	fmt.Println(v)
}
if err := errFunc(); err != nil {
	fmt.Println(err.Error())
}

i := iterkit.Slice1([]int{1, 2, 3})
next, stop := iter.Pull(i)
defer stop()
vs := iterkit.Take(next, 2)
_ = vs // []int{1, 2}

kvs := maps.All(map[string]int{
	"foo": 42,
	"bar": 7,
	"baz": 13,
})

next, stop := iter.Pull2(kvs)
defer stop()

type E struct {
	Key   string
	Value int
}

es := iterkit.Take2[E](next, 3, func(k string, v int) E {
	return E{Key: k, Value: v}
})

_ = len(es) // 3

i := iterkit.Slice1([]int{1, 2, 3, 4, 5})
next, stop := iter.Pull(i)
defer stop()
vs := iterkit.TakeAll(next)
_ = vs // []int{1, 2, 3, 4, 5}

var i iter.Seq2[int, int] = func(yield func(int, int) bool) {
	for i := range 3 {
		if !yield(i, i*2) {
			return
		}
	}
}

next, stop := iter.Pull2(i)
defer stop()

vs := iterkit.TakeAll2(next, func(n int, v int) int {
	return n + v
})

_ = vs

i := iterkit.SliceE([]int{1, 2, 3})
next, stop := iter.Pull2(i)
defer stop()
vs, err := iterkit.TakeE(next, 2)
_ = err // nil
_ = vs  // []int{1, 2}