iter

package

v0.0.16 Latest Latest Go to latest Published: Feb 13, 2024 License: MIT Imports: 11 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
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)
func WriteJSON[V any](iter Iter[V], encoder *json.Encoder) error
type Context
type HashMap
- func (m HashMap[K, V]) Iter() Iter[tuple.T2[K, V]]
- func (m HashMap[K, V]) Keys() Iter[K]
- func (m HashMap[K, V]) Values() Iter[V]
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 FromBytesScanner(scanner *bufio.Scanner) Iter[[]byte]
- func FromCSV(r *csv.Reader) Iter[[]string]
- func FromDir(dirname string) Iter[fs.FileInfo]
- func FromDirname(dirname string) Iter[string]
- func FromFunc[V any](f func(Context) (V, bool)) Iter[V]
- func FromJSON[V any](decoder *json.Decoder) 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 FromTextScanner(scanner *bufio.Scanner) Iter[string]
- 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)
type Iterable
type Slice
- func (slice Slice[V]) Iter() Iter[V]

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)

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

func WriteJSON ¶ added in v0.0.15

func WriteJSON[V any](iter Iter[V], encoder *json.Encoder) error

イテレータを json.Encoder に書き込む。

Types ¶

type Context ¶ added in v0.0.13

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

type HashMap ¶ added in v0.0.16

type HashMap[K comparable, V any] map[K]V

XXX: ほんとうは Map にしたいが、func Map と被ってしまう。

func (HashMap[K, V]) Iter ¶ added in v0.0.16

func (m HashMap[K, V]) Iter() Iter[tuple.T2[K, V]]

func (HashMap[K, V]) Keys ¶ added in v0.0.16

func (m HashMap[K, V]) Keys() Iter[K]

func (HashMap[K, V]) Values ¶ added in v0.0.16

func (m HashMap[K, V]) Values() Iter[V]

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 FromBytesScanner ¶ added in v0.0.15

func FromBytesScanner(scanner *bufio.Scanner) Iter[[]byte]

bufio.Scanner からイテレータをつくる。

func FromCSV ¶ added in v0.0.16

func FromCSV(r *csv.Reader) Iter[[]string]

csv.Reader からイテレータをつくる。

func FromDir ¶ added in v0.0.15

func FromDir(dirname string) Iter[fs.FileInfo]

ディレクトリ内のファイルからイテレータをつくる。

func FromDirname ¶ added in v0.0.15

func FromDirname(dirname string) Iter[string]

ディレクトリ内のファイル名からイテレータをつくる。

func FromFunc ¶ added in v0.0.13

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

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

func FromJSON ¶ added in v0.0.15

func FromJSON[V any](decoder *json.Decoder) Iter[V]

json.Decoder からイテレータをつくる。

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 FromTextScanner ¶ added in v0.0.15

func FromTextScanner(scanner *bufio.Scanner) Iter[string]

bufio.Scanner からイテレータをつくる。

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)

type Iterable ¶ added in v0.0.16

type Iterable[V any] interface {
	Iter() Iter[V]
}

type Slice ¶ added in v0.0.16

type Slice[V any] []V

func (Slice[V]) Iter ¶ added in v0.0.16

func (slice Slice[V]) Iter() Iter[V]

Source Files ¶

View all Source files

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