iter

package

v0.0.14 Latest Latest Go to latest Published: Nov 30, 2023 License: MIT Imports: 4 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/thamaji/gu

Links

Open Source Insights

Documentation ¶

Index ¶

func ContainsAll[V comparable](iter Iter[V], subset Iter[V]) (bool, error)
func ContainsAny[V comparable](iter Iter[V], subset Iter[V]) (bool, error)
func Count[V comparable](iter Iter[V], v V) (int, error)
func CountBy[V any](iter Iter[V], f func(V) (bool, error)) (int, error)
func EndsWith[V comparable](iter Iter[V], subset Iter[V]) (bool, error)
func Equal[V comparable](iter1 Iter[V], iter2 Iter[V]) (bool, error)
func EqualBy[V any](iter1 Iter[V], iter2 Iter[V], f func(V, V) (bool, error)) (bool, error)
func Exists[V comparable](iter Iter[V], v V) (bool, error)
func ExistsBy[V any](iter Iter[V], f func(V) (bool, error)) (bool, error)
func Find[V comparable](iter Iter[V], v V) (V, bool, error)
func FindBy[V any](iter Iter[V], f func(V) (bool, error)) (V, bool, error)
func Fold[V1 any, V2 any](iter Iter[V1], v V2, f func(V2, V1) (V2, error)) (V2, error)
func ForAll[V comparable](iter Iter[V], v V) (bool, error)
func ForAllBy[V any](iter Iter[V], f func(V) (bool, error)) (bool, error)
func ForEach[V any](iter Iter[V], f func(V) error) error
func Get[V any](iter Iter[V], index int) (V, bool, error)
func GetFirst[V any](iter Iter[V]) (V, bool, error)
func GetFirstOrElse[V any](iter Iter[V], v V) (V, error)
func GetLast[V any](iter Iter[V]) (V, bool, error)
func GetLastOrElse[V any](iter Iter[V], v V) (V, error)
func GetOrElse[V any](iter Iter[V], index int, v V) (V, error)
func GetOrFunc[V any](iter Iter[V], index int, f func() (V, error)) (V, error)
func GetOrNil[V any](iter Iter[V], index int) (*V, error)
func GetOrZero[V any](iter Iter[V], index int) (V, error)
func GroupBy[K comparable, V any](iter Iter[V], f func(V) (K, error)) (map[K][]V, error)
func Index[V comparable](iter Iter[V], v V) (int, error)
func IndexBy[V any](iter Iter[V], f func(V) (bool, error)) (int, error)
func LastIndex[V comparable](iter Iter[V], v V) (int, error)
func LastIndexBy[V any](iter Iter[V], f func(V) (bool, error)) (int, error)
func Len[V any](iter Iter[V]) (int, error)
func Max[V constraints.Ordered](iter Iter[V]) (V, error)
func MaxBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) (V2, error)
func Min[V constraints.Ordered](iter Iter[V]) (V, error)
func MinBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) (V2, error)
func MustContainsAll[V comparable](iter Iter[V], subset Iter[V]) bool
func MustContainsAny[V comparable](iter Iter[V], subset Iter[V]) bool
func MustCount[V comparable](iter Iter[V], v V) int
func MustCountBy[V any](iter Iter[V], f func(V) (bool, error)) int
func MustEndsWith[V comparable](iter Iter[V], subset Iter[V]) bool
func MustEqual[V comparable](iter1 Iter[V], iter2 Iter[V]) bool
func MustEqualBy[V any](iter1 Iter[V], iter2 Iter[V], f func(V, V) (bool, error)) bool
func MustExists[V comparable](iter Iter[V], v V) bool
func MustExistsBy[V any](iter Iter[V], f func(V) (bool, error)) bool
func MustFind[V comparable](iter Iter[V], v V) (V, bool)
func MustFindBy[V any](iter Iter[V], f func(V) (bool, error)) (V, bool)
func MustFold[V1 any, V2 any](iter Iter[V1], v V2, f func(V2, V1) (V2, error)) V2
func MustForAll[V comparable](iter Iter[V], v V) bool
func MustForAllBy[V any](iter Iter[V], f func(V) (bool, error)) bool
func MustForEach[V any](iter Iter[V], f func(V) error)
func MustGet[V any](iter Iter[V], index int) (V, bool)
func MustGetFirst[V any](iter Iter[V]) (V, bool)
func MustGetFirstOrElse[V any](iter Iter[V], v V) V
func MustGetLast[V any](iter Iter[V]) (V, bool)
func MustGetLastOrElse[V any](iter Iter[V], v V) V
func MustGetOrElse[V any](iter Iter[V], index int, v V) V
func MustGetOrFunc[V any](iter Iter[V], index int, f func() (V, error)) V
func MustGetOrNil[V any](iter Iter[V], index int) *V
func MustGetOrZero[V any](iter Iter[V], index int) V
func MustGroupBy[K comparable, V any](iter Iter[V], f func(V) (K, error)) map[K][]V
func MustIndex[V comparable](iter Iter[V], v V) int
func MustIndexBy[V any](iter Iter[V], f func(V) (bool, error)) int
func MustLastIndex[V comparable](iter Iter[V], v V) int
func MustLastIndexBy[V any](iter Iter[V], f func(V) (bool, error)) int
func MustLen[V any](iter Iter[V]) int
func MustMax[V constraints.Ordered](iter Iter[V]) V
func MustMaxBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) V2
func MustMin[V constraints.Ordered](iter Iter[V]) V
func MustMinBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) V2
func MustPartition[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])
func MustPartitionBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])
func MustReduce[V any](iter Iter[V], f func(V, V) (V, error)) V
func MustSpan[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])
func MustSpanBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])
func MustSplit[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])
func MustSplitAfter[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])
func MustSplitAfterBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])
func MustSplitBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])
func MustStartsWith[V comparable](iter Iter[V], subset Iter[V]) bool
func MustSum[V constraints.Ordered | constraints.Complex](iter Iter[V]) V
func MustSumBy[V1 any, V2 constraints.Ordered | constraints.Complex](iter Iter[V1], f func(V1) (V2, error)) V2
func MustToMap[K comparable, V any](iter Iter[tuple.T2[K, V]]) map[K]V
func MustToPtr[V any](iter Iter[V]) *V
func MustToSlice[V any](iter Iter[V]) []V
func Partition[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)
func PartitionBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)
func Reduce[V any](iter Iter[V], f func(V, V) (V, error)) (V, error)
func Span[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)
func SpanBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)
func Split[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)
func SplitAfter[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)
func SplitAfterBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)
func SplitBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)
func StartsWith[V comparable](iter Iter[V], subset Iter[V]) (bool, error)
func Sum[V constraints.Ordered | constraints.Complex](iter Iter[V]) (V, error)
func SumBy[V1 any, V2 constraints.Ordered | constraints.Complex](iter Iter[V1], f func(V1) (V2, error)) (V2, error)
func ToMap[K comparable, V any](iter Iter[tuple.T2[K, V]]) (map[K]V, error)
func ToPtr[V any](iter Iter[V]) (*V, error)
func ToSlice[V any](iter Iter[V]) ([]V, error)
func Unzip2[V1 any, V2 any](iter Iter[tuple.T2[V1, V2]]) (Iter[V1], Iter[V2], error)
func Unzip3[V1 any, V2 any, V3 any](iter Iter[tuple.T3[V1, V2, V3]]) (Iter[V1], Iter[V2], Iter[V3], error)
func Unzip4[V1 any, V2 any, V3 any, V4 any](iter Iter[tuple.T4[V1, V2, V3, V4]]) (Iter[V1], Iter[V2], Iter[V3], Iter[V4], error)
func Unzip5[V1 any, V2 any, V3 any, V4 any, V5 any](iter Iter[tuple.T5[V1, V2, V3, V4, V5]]) (Iter[V1], Iter[V2], Iter[V3], Iter[V4], Iter[V5], error)
func Unzip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](iter Iter[tuple.T6[V1, V2, V3, V4, V5, V6]]) (Iter[V1], Iter[V2], Iter[V3], Iter[V4], Iter[V5], Iter[V6], error)
type Context
type Iter
- func Append[V any](iter Iter[V], v ...V) Iter[V]
- func Clean[V comparable](iter Iter[V]) Iter[V]
- func Collect[V1 any, V2 any](iter Iter[V1], f func(V1) (V2, bool, error)) Iter[V2]
- func Concat[V any](iter1 Iter[V], iter2 ...Iter[V]) Iter[V]
- func Distinct[V comparable](iter Iter[V]) Iter[V]
- func Drop[V any](iter Iter[V], n int) Iter[V]
- func DropWhile[V comparable](iter Iter[V], v V) Iter[V]
- func DropWhileBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]
- func Empty[V any]() Iter[V]
- func Filter[V comparable](iter Iter[V], v V) Iter[V]
- func FilterBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]
- func FilterNot[V comparable](iter Iter[V], v V) Iter[V]
- func FilterNotBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]
- func FlatMap[V1 any, V2 any](iter Iter[V1], f func(V1) (Iter[V2], error)) Iter[V2]
- func Flatten[V any](iter Iter[Iter[V]]) Iter[V]
- func From[V any](values ...V) Iter[V]
- func FromFunc[V any](f func(Context) (V, bool)) Iter[V]
- func FromMap[K comparable, V any](m map[K]V) Iter[tuple.T2[K, V]]
- func FromMapKeys[K comparable, V any](m map[K]V) Iter[K]
- func FromMapValues[K comparable, V any](m map[K]V) Iter[V]
- func FromPtr[V any](p *V) Iter[V]
- func FromSlice[V any](slice []V) Iter[V]
- func Indices[V any](iter Iter[V]) Iter[int]
- func Insert[V any](iter Iter[V], index int, v ...V) Iter[V]
- func Join[V any](iter Iter[V], separator V) Iter[V]
- func Map[V1 any, V2 any](iter Iter[V1], f func(V1) (V2, error)) Iter[V2]
- func Option[V any](v V, ok bool) Iter[V]
- func Range[V constraints.Ordered](start V, stop V, step V) Iter[V]
- func Remove[V any](iter Iter[V], index int) Iter[V]
- func Replace[V comparable](iter Iter[V], old V, new V) Iter[V]
- func ReplaceAll[V comparable](iter Iter[V], old V, new V) Iter[V]
- func Take[V any](iter Iter[V], n int) Iter[V]
- func TakeWhile[V comparable](iter Iter[V], v V) Iter[V]
- func TakeWhileBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]
- func Zip2[V1 any, V2 any](iter1 Iter[V1], iter2 Iter[V2]) Iter[tuple.T2[V1, V2]]
- func Zip3[V1 any, V2 any, V3 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3]) Iter[tuple.T3[V1, V2, V3]]
- func Zip4[V1 any, V2 any, V3 any, V4 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3], iter4 Iter[V4]) Iter[tuple.T4[V1, V2, V3, V4]]
- func Zip5[V1 any, V2 any, V3 any, V4 any, V5 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3], iter4 Iter[V4], iter5 Iter[V5]) Iter[tuple.T5[V1, V2, V3, V4, V5]]
- func Zip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3], iter4 Iter[V4], iter5 Iter[V5], ...) Iter[tuple.T6[V1, V2, V3, V4, V5, V6]]
- func ZipWithIndex[V any](iter Iter[V]) Iter[tuple.T2[V, int]]
type IterFunc
- func (f IterFunc[V]) Err() error
- func (f IterFunc[V]) Next() (V, bool)

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func ContainsAll ¶

func ContainsAll[V comparable](iter Iter[V], subset Iter[V]) (bool, error)

他のイテレータの値がすべて存在していたらtrueを返す。

func ContainsAny ¶

func ContainsAny[V comparable](iter Iter[V], subset Iter[V]) (bool, error)

他のイテレータの値がひとつでも存在していたらtrueを返す。

func Count ¶

func Count[V comparable](iter Iter[V], v V) (int, error)

一致する値の数を返す。

func CountBy ¶

func CountBy[V any](iter Iter[V], f func(V) (bool, error)) (int, error)

条件を満たす値の数を返す。

func EndsWith ¶

func EndsWith[V comparable](iter Iter[V], subset Iter[V]) (bool, error)

終端が他のイテレータと一致していたらtrueを返す。

func Equal ¶

func Equal[V comparable](iter1 Iter[V], iter2 Iter[V]) (bool, error)

他のイテレータと一致していたらtrueを返す。

func EqualBy ¶

func EqualBy[V any](iter1 Iter[V], iter2 Iter[V], f func(V, V) (bool, error)) (bool, error)

他のイテレータと関数で比較し、一致していたらtrueを返す。

func Exists ¶

func Exists[V comparable](iter Iter[V], v V) (bool, error)

一致する値が存在したらtrueを返す。

func ExistsBy ¶

func ExistsBy[V any](iter Iter[V], f func(V) (bool, error)) (bool, error)

条件を満たす値が存在したらtrueを返す。

func Find ¶

func Find[V comparable](iter Iter[V], v V) (V, bool, error)

一致する値を返す。

func FindBy ¶

func FindBy[V any](iter Iter[V], f func(V) (bool, error)) (V, bool, error)

条件を満たす値を返す。

func Fold ¶

func Fold[V1 any, V2 any](iter Iter[V1], v V2, f func(V2, V1) (V2, error)) (V2, error)

初期値と値を順に演算する。

func ForAll ¶

func ForAll[V comparable](iter Iter[V], v V) (bool, error)

すべての値が一致したらtrueを返す。

func ForAllBy ¶

func ForAllBy[V any](iter Iter[V], f func(V) (bool, error)) (bool, error)

すべての値が条件を満たせばtrueを返す。

func ForEach ¶

func ForEach[V any](iter Iter[V], f func(V) error) error

値ごとに関数を実行する。

func Get ¶

func Get[V any](iter Iter[V], index int) (V, bool, error)

指定した位置の値を返す。

func GetFirst ¶

func GetFirst[V any](iter Iter[V]) (V, bool, error)

先頭の値を返す。

func GetFirstOrElse ¶

func GetFirstOrElse[V any](iter Iter[V], v V) (V, error)

先頭の値を返す。無い場合はvを返す。

func GetLast ¶

func GetLast[V any](iter Iter[V]) (V, bool, error)

終端の値を返す。

func GetLastOrElse ¶

func GetLastOrElse[V any](iter Iter[V], v V) (V, error)

終端の値を返す。無い場合はvを返す。

func GetOrElse ¶

func GetOrElse[V any](iter Iter[V], index int, v V) (V, error)

指定した位置の値を返す。無い場合はvを返す。

func GetOrFunc ¶ added in v0.0.3

func GetOrFunc[V any](iter Iter[V], index int, f func() (V, error)) (V, error)

指定した位置の要素を返す。無い場合は関数の実行結果を返す。

func GetOrNil ¶ added in v0.0.6

func GetOrNil[V any](iter Iter[V], index int) (*V, error)

指定した位置の値のポインタを返す。無い場合はnilを返す。

func GetOrZero ¶ added in v0.0.6

func GetOrZero[V any](iter Iter[V], index int) (V, error)

指定した位置の値を返す。無い場合はゼロ値を返す。

func GroupBy ¶

func GroupBy[K comparable, V any](iter Iter[V], f func(V) (K, error)) (map[K][]V, error)

値ごとに関数の返すキーでグルーピングしたマップを返す。

func Index ¶

func Index[V comparable](iter Iter[V], v V) (int, error)

一致する最初の値の位置を返す。

func IndexBy ¶

func IndexBy[V any](iter Iter[V], f func(V) (bool, error)) (int, error)

条件を満たす最初の値の位置を返す。

func LastIndex ¶

func LastIndex[V comparable](iter Iter[V], v V) (int, error)

一致する最後の値の位置を返す。

func LastIndexBy ¶

func LastIndexBy[V any](iter Iter[V], f func(V) (bool, error)) (int, error)

条件を満たす最後の値の位置を返す。

func Len ¶

func Len[V any](iter Iter[V]) (int, error)

値の数を返す。

func Max ¶

func Max[V constraints.Ordered](iter Iter[V]) (V, error)

最大の値を返す。

func MaxBy ¶

func MaxBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) (V2, error)

値を変換して最大の値を返す。

func Min ¶

func Min[V constraints.Ordered](iter Iter[V]) (V, error)

最小の値を返す。

func MinBy ¶

func MinBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) (V2, error)

値を変換して最小の値を返す。

func MustContainsAll ¶ added in v0.0.6

func MustContainsAll[V comparable](iter Iter[V], subset Iter[V]) bool

他のイテレータの値がすべて存在していたらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustContainsAny ¶ added in v0.0.6

func MustContainsAny[V comparable](iter Iter[V], subset Iter[V]) bool

他のイテレータの値がひとつでも存在していたらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustCount ¶ added in v0.0.6

func MustCount[V comparable](iter Iter[V], v V) int

一致する値の数を返す。実行中にエラーが起きた場合 panic する。

func MustCountBy ¶ added in v0.0.6

func MustCountBy[V any](iter Iter[V], f func(V) (bool, error)) int

条件を満たす値の数を返す。実行中にエラーが起きた場合 panic する。

func MustEndsWith ¶ added in v0.0.6

func MustEndsWith[V comparable](iter Iter[V], subset Iter[V]) bool

終端が他のイテレータと一致していたらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustEqual ¶ added in v0.0.6

func MustEqual[V comparable](iter1 Iter[V], iter2 Iter[V]) bool

他のイテレータと一致していたらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustEqualBy ¶ added in v0.0.6

func MustEqualBy[V any](iter1 Iter[V], iter2 Iter[V], f func(V, V) (bool, error)) bool

他のイテレータと関数で比較し、一致していたらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustExists ¶ added in v0.0.6

func MustExists[V comparable](iter Iter[V], v V) bool

一致する値が存在したらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustExistsBy ¶ added in v0.0.6

func MustExistsBy[V any](iter Iter[V], f func(V) (bool, error)) bool

条件を満たす値が存在したらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustFind ¶ added in v0.0.6

func MustFind[V comparable](iter Iter[V], v V) (V, bool)

一致する値を返す。実行中にエラーが起きた場合 panic する。

func MustFindBy ¶ added in v0.0.6

func MustFindBy[V any](iter Iter[V], f func(V) (bool, error)) (V, bool)

条件を満たす値を返す。実行中にエラーが起きた場合 panic する。

func MustFold ¶ added in v0.0.6

func MustFold[V1 any, V2 any](iter Iter[V1], v V2, f func(V2, V1) (V2, error)) V2

初期値と値を順に演算する。実行中にエラーが起きた場合 panic する。

func MustForAll ¶ added in v0.0.6

func MustForAll[V comparable](iter Iter[V], v V) bool

すべての値が一致したらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustForAllBy ¶ added in v0.0.6

func MustForAllBy[V any](iter Iter[V], f func(V) (bool, error)) bool

すべての値が条件を満たせばtrueを返す。実行中にエラーが起きた場合 panic する。

func MustForEach ¶ added in v0.0.6

func MustForEach[V any](iter Iter[V], f func(V) error)

値ごとに関数を実行する。実行中にエラーが起きた場合 panic する。

func MustGet ¶ added in v0.0.6

func MustGet[V any](iter Iter[V], index int) (V, bool)

指定した位置の値を返す。実行中にエラーが起きた場合 panic する。

func MustGetFirst ¶ added in v0.0.6

func MustGetFirst[V any](iter Iter[V]) (V, bool)

先頭の値を返す。実行中にエラーが起きた場合 panic する。

func MustGetFirstOrElse ¶ added in v0.0.6

func MustGetFirstOrElse[V any](iter Iter[V], v V) V

先頭の値を返す。無い場合はvを返す。実行中にエラーが起きた場合 panic する。

func MustGetLast ¶ added in v0.0.6

func MustGetLast[V any](iter Iter[V]) (V, bool)

終端の値を返す。実行中にエラーが起きた場合 panic する。

func MustGetLastOrElse ¶ added in v0.0.6

func MustGetLastOrElse[V any](iter Iter[V], v V) V

終端の値を返す。無い場合はvを返す。実行中にエラーが起きた場合 panic する。

func MustGetOrElse ¶ added in v0.0.6

func MustGetOrElse[V any](iter Iter[V], index int, v V) V

指定した位置の値を返す。無い場合はvを返す。実行中にエラーが起きた場合 panic する。

func MustGetOrFunc ¶ added in v0.0.6

func MustGetOrFunc[V any](iter Iter[V], index int, f func() (V, error)) V

指定した位置の要素を返す。無い場合は関数の実行結果を返す。実行中にエラーが起きた場合 panic する。

func MustGetOrNil ¶ added in v0.0.6

func MustGetOrNil[V any](iter Iter[V], index int) *V

指定した位置の値のポインタを返す。無い場合はnilを返す。実行中にエラーが起きた場合 panic する。

func MustGetOrZero ¶ added in v0.0.6

func MustGetOrZero[V any](iter Iter[V], index int) V

指定した位置の値を返す。無い場合はゼロ値を返す。実行中にエラーが起きた場合 panic する。

func MustGroupBy ¶ added in v0.0.6

func MustGroupBy[K comparable, V any](iter Iter[V], f func(V) (K, error)) map[K][]V

値ごとに関数の返すキーでグルーピングしたマップを返す。実行中にエラーが起きた場合 panic する。

func MustIndex ¶ added in v0.0.6

func MustIndex[V comparable](iter Iter[V], v V) int

一致する最初の値の位置を返す。実行中にエラーが起きた場合 panic する。

func MustIndexBy ¶ added in v0.0.6

func MustIndexBy[V any](iter Iter[V], f func(V) (bool, error)) int

条件を満たす最初の値の位置を返す。実行中にエラーが起きた場合 panic する。

func MustLastIndex ¶ added in v0.0.6

func MustLastIndex[V comparable](iter Iter[V], v V) int

一致する最後の値の位置を返す。実行中にエラーが起きた場合 panic する。

func MustLastIndexBy ¶ added in v0.0.6

func MustLastIndexBy[V any](iter Iter[V], f func(V) (bool, error)) int

条件を満たす最後の値の位置を返す。実行中にエラーが起きた場合 panic する。

func MustLen ¶ added in v0.0.6

func MustLen[V any](iter Iter[V]) int

値の数を返す。実行中にエラーが起きた場合 panic する。

func MustMax ¶ added in v0.0.6

func MustMax[V constraints.Ordered](iter Iter[V]) V

最大の値を返す。実行中にエラーが起きた場合 panic する。

func MustMaxBy ¶ added in v0.0.6

func MustMaxBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) V2

値を変換して最大の値を返す。実行中にエラーが起きた場合 panic する。

func MustMin ¶ added in v0.0.6

func MustMin[V constraints.Ordered](iter Iter[V]) V

最小の値を返す。実行中にエラーが起きた場合 panic する。

func MustMinBy ¶ added in v0.0.6

func MustMinBy[V1 any, V2 constraints.Ordered](iter Iter[V1], f func(V1) (V2, error)) V2

値を変換して最小の値を返す。実行中にエラーが起きた場合 panic する。

func MustPartition ¶ added in v0.0.6

func MustPartition[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])

値の一致するイテレータと一致しないイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustPartitionBy ¶ added in v0.0.6

func MustPartitionBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])

条件を満たすイテレータと満たさないイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustReduce ¶ added in v0.0.6

func MustReduce[V any](iter Iter[V], f func(V, V) (V, error)) V

値を順に演算する。実行中にエラーが起きた場合 panic する。

func MustSpan ¶ added in v0.0.6

func MustSpan[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])

一致し続ける先頭部分と残りの部分、ふたつのイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustSpanBy ¶ added in v0.0.6

func MustSpanBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])

条件を満たし続ける先頭部分と残りの部分、ふたつのイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustSplit ¶ added in v0.0.6

func MustSplit[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])

一致する値の直前で分割したふたつのイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustSplitAfter ¶ added in v0.0.6

func MustSplitAfter[V comparable](iter Iter[V], v V) (Iter[V], Iter[V])

一致する値の直後で分割したふたつのイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustSplitAfterBy ¶ added in v0.0.6

func MustSplitAfterBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])

条件を満たす値の直後で分割したふたつのイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustSplitBy ¶ added in v0.0.6

func MustSplitBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V])

条件を満たす値の直前で分割したふたつのイテレータを返す。実行中にエラーが起きた場合 panic する。

func MustStartsWith ¶ added in v0.0.6

func MustStartsWith[V comparable](iter Iter[V], subset Iter[V]) bool

先頭が他のイテレータと一致していたらtrueを返す。実行中にエラーが起きた場合 panic する。

func MustSum ¶ added in v0.0.6

func MustSum[V constraints.Ordered | constraints.Complex](iter Iter[V]) V

値の合計を演算する。実行中にエラーが起きた場合 panic する。

func MustSumBy ¶ added in v0.0.6

func MustSumBy[V1 any, V2 constraints.Ordered | constraints.Complex](iter Iter[V1], f func(V1) (V2, error)) V2

値を変換して合計を演算する。実行中にエラーが起きた場合 panic する。

func MustToMap ¶ added in v0.0.6

func MustToMap[K comparable, V any](iter Iter[tuple.T2[K, V]]) map[K]V

イテレータからマップをつくる。実行中にエラーが起きた場合 panic する。

func MustToPtr ¶ added in v0.0.6

func MustToPtr[V any](iter Iter[V]) *V

イテレータからポインタをつくる。実行中にエラーが起きた場合 panic する。ふたつ目以降の値は無視される。

func MustToSlice ¶ added in v0.0.6

func MustToSlice[V any](iter Iter[V]) []V

イテレータからスライスをつくる。実行中にエラーが起きた場合 panic する。

func Partition ¶

func Partition[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)

値の一致するイテレータと一致しないイテレータを返す。

func PartitionBy ¶

func PartitionBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)

条件を満たすイテレータと満たさないイテレータを返す。

func Reduce ¶

func Reduce[V any](iter Iter[V], f func(V, V) (V, error)) (V, error)

値を順に演算する。

func Span ¶

func Span[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)

一致し続ける先頭部分と残りの部分、ふたつのイテレータを返す。

func SpanBy ¶

func SpanBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)

条件を満たし続ける先頭部分と残りの部分、ふたつのイテレータを返す。

func Split ¶

func Split[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)

一致する値の直前で分割したふたつのイテレータを返す。

func SplitAfter ¶

func SplitAfter[V comparable](iter Iter[V], v V) (Iter[V], Iter[V], error)

一致する値の直後で分割したふたつのイテレータを返す。

func SplitAfterBy ¶

func SplitAfterBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)

条件を満たす値の直後で分割したふたつのイテレータを返す。

func SplitBy ¶

func SplitBy[V any](iter Iter[V], f func(V) (bool, error)) (Iter[V], Iter[V], error)

条件を満たす値の直前で分割したふたつのイテレータを返す。

func StartsWith ¶

func StartsWith[V comparable](iter Iter[V], subset Iter[V]) (bool, error)

先頭が他のイテレータと一致していたらtrueを返す。

func Sum ¶

func Sum[V constraints.Ordered | constraints.Complex](iter Iter[V]) (V, error)

値の合計を演算する。

func SumBy ¶

func SumBy[V1 any, V2 constraints.Ordered | constraints.Complex](iter Iter[V1], f func(V1) (V2, error)) (V2, error)

値を変換して合計を演算する。

func ToMap ¶

func ToMap[K comparable, V any](iter Iter[tuple.T2[K, V]]) (map[K]V, error)

イテレータからマップをつくる。

func ToPtr ¶

func ToPtr[V any](iter Iter[V]) (*V, error)

イテレータからポインタをつくる。ふたつ目以降の値は無視される。

func ToSlice ¶

func ToSlice[V any](iter Iter[V]) ([]V, error)

イテレータからスライスをつくる。

func Unzip2 ¶

func Unzip2[V1 any, V2 any](iter Iter[tuple.T2[V1, V2]]) (Iter[V1], Iter[V2], error)

値のペアを分離して２つのイテレータを返す。

func Unzip3 ¶

func Unzip3[V1 any, V2 any, V3 any](iter Iter[tuple.T3[V1, V2, V3]]) (Iter[V1], Iter[V2], Iter[V3], error)

値のペアを分離して３つのイテレータを返す。

func Unzip4 ¶

func Unzip4[V1 any, V2 any, V3 any, V4 any](iter Iter[tuple.T4[V1, V2, V3, V4]]) (Iter[V1], Iter[V2], Iter[V3], Iter[V4], error)

値のペアを分離して４つのイテレータを返す。

func Unzip5 ¶

func Unzip5[V1 any, V2 any, V3 any, V4 any, V5 any](iter Iter[tuple.T5[V1, V2, V3, V4, V5]]) (Iter[V1], Iter[V2], Iter[V3], Iter[V4], Iter[V5], error)

値のペアを分離して５つのイテレータを返す。

func Unzip6 ¶

func Unzip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](iter Iter[tuple.T6[V1, V2, V3, V4, V5, V6]]) (Iter[V1], Iter[V2], Iter[V3], Iter[V4], Iter[V5], Iter[V6], error)

値のペアを分離して６つのイテレータを返す。

Types ¶

type Context ¶ added in v0.0.13

type Context interface {
	SetErr(error)
	Err() error
}

type Iter ¶

type Iter[V any] interface {
	// 次の値を返す。
	// 第２戻り値は値があるときは true、なければ false を返す。
	Next() (V, bool)
	Err() error
}

func Append ¶

func Append[V any](iter Iter[V], v ...V) Iter[V]

イテレータの末尾に値を追加する。

func Clean ¶

func Clean[V comparable](iter Iter[V]) Iter[V]

ゼロ値を除いたイテレータを返す。

func Collect ¶

func Collect[V1 any, V2 any](iter Iter[V1], f func(V1) (V2, bool, error)) Iter[V2]

条件を満たす値を変換したイテレータを返す。

func Concat ¶

func Concat[V any](iter1 Iter[V], iter2 ...Iter[V]) Iter[V]

イテレータの末尾に他のイテレータを結合する。

func Distinct ¶

func Distinct[V comparable](iter Iter[V]) Iter[V]

重複を除いたイテレータを返す。

func Drop ¶

func Drop[V any](iter Iter[V], n int) Iter[V]

先頭n個の値を除いたイテレータを返す。

func DropWhile ¶

func DropWhile[V comparable](iter Iter[V], v V) Iter[V]

一致し続ける先頭の値を除いたイテレータを返す。

func DropWhileBy ¶

func DropWhileBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]

条件を満たし続ける先頭の値を除いたイテレータを返す。

func Empty ¶

func Empty[V any]() Iter[V]

func Filter ¶

func Filter[V comparable](iter Iter[V], v V) Iter[V]

一致する値だけのイテレータを返す。

func FilterBy ¶

func FilterBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]

条件を満たす値だけのイテレータを返す。

func FilterNot ¶

func FilterNot[V comparable](iter Iter[V], v V) Iter[V]

一致する値を除いたイテレータを返す。

func FilterNotBy ¶

func FilterNotBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]

条件を満たす値を除いたイテレータを返す。

func FlatMap ¶

func FlatMap[V1 any, V2 any](iter Iter[V1], f func(V1) (Iter[V2], error)) Iter[V2]

値をイテレータに変換し、それらを結合したイテレータを返す。

func Flatten ¶

func Flatten[V any](iter Iter[Iter[V]]) Iter[V]

平坦化したイテレータを返す。

func From ¶

func From[V any](values ...V) Iter[V]

複数の値からイテレータをつくる。

func FromFunc ¶ added in v0.0.13

func FromFunc[V any](f func(Context) (V, bool)) Iter[V]

関数からイテレータをつくる。

func FromMap ¶

func FromMap[K comparable, V any](m map[K]V) Iter[tuple.T2[K, V]]

マップからイテレータをつくる。

func FromMapKeys ¶

func FromMapKeys[K comparable, V any](m map[K]V) Iter[K]

マップのキーからイテレータをつくる。

func FromMapValues ¶

func FromMapValues[K comparable, V any](m map[K]V) Iter[V]

マップの値からイテレータをつくる。

func FromPtr ¶

func FromPtr[V any](p *V) Iter[V]

ポインタからイテレータをつくる。

func FromSlice ¶

func FromSlice[V any](slice []V) Iter[V]

スライスからイテレータをつくる。

func Indices ¶

func Indices[V any](iter Iter[V]) Iter[int]

位置のイテレータを返す。

func Insert ¶

func Insert[V any](iter Iter[V], index int, v ...V) Iter[V]

指定した位置に値を追加する。

func Join ¶

func Join[V any](iter Iter[V], separator V) Iter[V]

値のあいだにseparatorを挿入したイテレータを返す。

func Map ¶

func Map[V1 any, V2 any](iter Iter[V1], f func(V1) (V2, error)) Iter[V2]

値を変換したイテレータを返す。

func Option ¶

func Option[V any](v V, ok bool) Iter[V]

値と値の有無を受け取ってイテレータをつくる。

func Range ¶

func Range[V constraints.Ordered](start V, stop V, step V) Iter[V]

範囲を指定してイテレータをつくる。

func Remove ¶

func Remove[V any](iter Iter[V], index int) Iter[V]

指定した位置の値を削除する。

func Replace ¶

func Replace[V comparable](iter Iter[V], old V, new V) Iter[V]

ひとつめのoldをnewで置き換えたイテレータを返す。

func ReplaceAll ¶

func ReplaceAll[V comparable](iter Iter[V], old V, new V) Iter[V]

すべてのoldをnewで置き換えたイテレータを返す。

func Take ¶

func Take[V any](iter Iter[V], n int) Iter[V]

先頭n個の値のイテレータを返す。

func TakeWhile ¶

func TakeWhile[V comparable](iter Iter[V], v V) Iter[V]

一致し続ける先頭の値のイテレータを返す。

func TakeWhileBy ¶

func TakeWhileBy[V any](iter Iter[V], f func(V) (bool, error)) Iter[V]

条件を満たし続ける先頭の値のイテレータを返す。

func Zip2 ¶

func Zip2[V1 any, V2 any](iter1 Iter[V1], iter2 Iter[V2]) Iter[tuple.T2[V1, V2]]

２つのイテレータの同じ位置の値をペアにしたイテレータを返す。

func Zip3 ¶

func Zip3[V1 any, V2 any, V3 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3]) Iter[tuple.T3[V1, V2, V3]]

３つのイテレータの同じ位置の値をペアにしたイテレータを返す。

func Zip4 ¶

func Zip4[V1 any, V2 any, V3 any, V4 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3], iter4 Iter[V4]) Iter[tuple.T4[V1, V2, V3, V4]]

４つのイテレータの同じ位置の値をペアにしたイテレータを返す。

func Zip5 ¶

func Zip5[V1 any, V2 any, V3 any, V4 any, V5 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3], iter4 Iter[V4], iter5 Iter[V5]) Iter[tuple.T5[V1, V2, V3, V4, V5]]

５つのイテレータの同じ位置の値をペアにしたイテレータを返す。

func Zip6 ¶

func Zip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](iter1 Iter[V1], iter2 Iter[V2], iter3 Iter[V3], iter4 Iter[V4], iter5 Iter[V5], iter6 Iter[V6]) Iter[tuple.T6[V1, V2, V3, V4, V5, V6]]

６つのイテレータの同じ位置の値をペアにしたイテレータを返す。

func ZipWithIndex ¶

func ZipWithIndex[V any](iter Iter[V]) Iter[tuple.T2[V, int]]

値と位置をペアにしたイテレータを返す。

type IterFunc ¶

type IterFunc[V any] func() (V, bool)

func (IterFunc[V]) Err ¶

func (f IterFunc[V]) Err() error

func (IterFunc[V]) Next ¶

func (f IterFunc[V]) Next() (V, bool)

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL