You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

46 lines
1.2 KiB
Go

3 years ago
package iter
type slice[T any] []T
type sliceIter[T any] struct {
s slice[T]
i int
}
func (it *sliceIter[T]) Next(v *T) bool {
if it.i >= len(it.s) {
return false
}
*v = it.s[it.i]
it.i++
return true
}
func (it *sliceIter[T]) Iter() Ator[T] { return &sliceIter[T]{s: it.s} }
func (s slice[T]) Iter() Ator[T] { return &sliceIter[T]{s: s} }
// Slice takes a slice and returns an iterable backed by that slice.
//
// ok so, asn an aside: normally you would write a function to return the
// concrete implementation, not an interface, but if I return the concrete
// implementation for an iter.Able, the type inference doesn't work correctly
// with the type parameters in some cases.
//
// So let's say we had an exported type Slice that was defined as:
//
// type Slice[T any] []T
//
// And we tried to convert a []int to a Slice[int], we could so that with:
//
// Slice([]int{1, 2, 3})
//
// And that would be fine until we try to do soething like pass it to Start.
// Returning Able[T] here means we can say Start(Slice([]int{1, 2, 3})), but if
// we had type Slice[T any] []T, we would have to say:
//
// Start[int](Slice([]int{1, 2, 3}))
//
// ...and I think that's annoying.
func Slice[T any](s []T) Able[T] { return slice[T](s) }