slices

package

v0.0.16 Latest Latest Go to latest Published: Feb 13, 2024 License: MIT Imports: 5 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 Append[S ~[]V, V any](slice S, v ...V) S
func Clean[S ~[]V, V comparable](slice S) S
func Clear[S ~[]V, V any](slice S) S
func Clone[S ~[]V, V any](slice S) S
func Collect[V1 any, V2 any](slice []V1, f func(V1) (V2, bool, error)) ([]V2, error)
func Concat[S ~[]V, V any](slice1 S, slice2 []V) S
func ContainsAll[V comparable](slice []V, subset []V) bool
func ContainsAny[V comparable](slice []V, subset []V) bool
func Count[V comparable](slice []V, v V) int
func CountBy[V any](slice []V, f func(V) (bool, error)) (int, error)
func Distinct[S ~[]V, V comparable](slice S) S
func Drop[S ~[]V, V any](slice S, n int) S
func DropWhile[S ~[]V, V comparable](slice S, v V) S
func DropWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)
func EndsWith[V comparable](slice []V, subset []V) bool
func Equal[V comparable](slice1 []V, slice2 []V) bool
func EqualBy[V any](slice1 []V, slice2 []V, f func(V, V) (bool, error)) (bool, error)
func Exists[V comparable](slice []V, v V) bool
func ExistsBy[V any](slice []V, f func(V) (bool, error)) (bool, error)
func Fill[V any](slice []V, v V)
func FillBy[V any](slice []V, f func(int) (V, error)) error
func FillZero[V any](slice []V)
func Filter[S ~[]V, V comparable](slice S, v V) S
func FilterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)
func FilterNot[S ~[]V, V comparable](slice S, v V) S
func FilterNotBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)
func Find[V comparable](slice []V, v V) (V, bool)
func FindBy[V any](slice []V, f func(V) (bool, error)) (V, bool, error)
func FlatMap[V1, V2 any](slice []V1, f func(V1) ([]V2, error)) ([]V2, error)
func Flatten[S ~[]V, V any](slice []S) S
func Fold[V1 any, V2 any](slice []V1, v V2, f func(V2, V1) (V2, error)) (V2, error)
func ForAll[V comparable](slice []V, v V) bool
func ForAllBy[V any](slice []V, f func(V) (bool, error)) (bool, error)
func ForEach[V any](slice []V, f func(V) error) error
func From[T any](values ...T) []T
func FromIter[V any](iter iter.Iter[V]) []V
func FromMap[K comparable, V any](m map[K]V) []tuple.T2[K, V]
func FromMapKeys[K comparable, V any](m map[K]V) []K
func FromMapValues[K comparable, V any](m map[K]V) []V
func FromPtr[T any](v *T) []T
func Get[V any](slice []V, index int) (V, bool)
func GetFirst[V any](slice []V) (V, bool)
func GetFirstOrElse[V any](slice []V, v V) V
func GetLast[V any](slice []V) (V, bool)
func GetLastOrElse[V any](slice []V, v V) V
func GetOrElse[V any](slice []V, index int, v V) V
func GetOrFunc[V any](slice []V, index int, f func() (V, error)) (V, error)
func GetOrNil[V any](slice []V, index int) *V
func GetOrZero[V any](slice []V, index int) V
func GroupBy[S ~[]V, K comparable, V any](slice S, f func(V) (K, error)) (map[K]S, error)
func Grouped[S ~[]V, V any](slice S, n int) []S
func Index[V comparable](slice []V, v V) int
func IndexBy[V any](slice []V, f func(V) (bool, error)) (int, error)
func Indices[V any](slice []V) []int
func Insert[S ~[]V, V any](slice S, index int, v ...V) S
func IsEmpty[V any](slice []V) bool
func Join[S ~[]V, V any](slice S, separator V) S
func LastIndex[V comparable](slice []V, v V) int
func LastIndexBy[V any](slice []V, f func(V) (bool, error)) (int, error)
func Len[V any](slice []V) int
func Map[V1 any, V2 any](slice []V1, f func(V1) (V2, error)) ([]V2, error)
func Max[V constraints.Ordered](slice []V) V
func MaxBy[V1 any, V2 constraints.Ordered](slice []V1, f func(V1) (V2, error)) (V2, error)
func Min[V constraints.Ordered](slice []V) V
func MinBy[V1 any, V2 constraints.Ordered](slice []V1, f func(V1) (V2, error)) (V2, error)
func MustCollect[V1 any, V2 any](slice []V1, f func(V1) (V2, bool, error)) []V2
func MustCountBy[V any](slice []V, f func(V) (bool, error)) int
func MustDropWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S
func MustEqualBy[V any](slice1 []V, slice2 []V, f func(V, V) (bool, error)) bool
func MustExistsBy[V any](slice []V, f func(V) (bool, error)) bool
func MustFilterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S
func MustFilterNotBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S
func MustFindBy[V any](slice []V, f func(V) (bool, error)) (V, bool)
func MustFlatMap[V1, V2 any](slice []V1, f func(V1) ([]V2, error)) []V2
func MustFold[V1 any, V2 any](slice []V1, v V2, f func(V2, V1) (V2, error)) V2
func MustForAllBy[V any](slice []V, f func(V) (bool, error)) bool
func MustForEach[V any](slice []V, f func(V) error)
func MustGetOrFunc[V any](slice []V, index int, f func() (V, error)) V
func MustGroupBy[S ~[]V, K comparable, V any](slice S, f func(V) (K, error)) map[K]S
func MustIndexBy[V any](slice []V, f func(V) (bool, error)) int
func MustLastIndexBy[V any](slice []V, f func(V) (bool, error)) int
func MustMap[V1 any, V2 any](slice []V1, f func(V1) (V2, error)) []V2
func MustMaxBy[V1 any, V2 constraints.Ordered](slice []V1, f func(V1) (V2, error)) V2
func MustMinBy[V1 any, V2 constraints.Ordered](slice []V1, f func(V1) (V2, error)) V2
func MustPadBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) S
func MustPadRightBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) S
func MustPartitionBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)
func MustReduce[V any](slice []V, f func(V, V) (V, error)) V
func MustSpanBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)
func MustSplitAfter[S ~[]V, V comparable](slice S, v V) (S, S)
func MustSplitAfterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)
func MustSplitBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)
func MustSumBy[V1 any, V2 constraints.Ordered | constraints.Complex](slice []V1, f func(V1) (V2, error)) V2
func MustTakeWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S
func Option[V any](v V, ok bool) []V
func Pad[S ~[]V, V any](slice S, n int, v V) S
func PadBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) (S, error)
func PadRight[S ~[]V, V any](slice S, n int, v V) S
func PadRightBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) (S, error)
func PadZero[S ~[]V, V any](slice S, n int) S
func PadZeroRight[S ~[]V, V any](slice S, n int) S
func Partition[S ~[]V, V comparable](slice S, v V) (S, S)
func PartitionBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)
func Range[V constraints.Integer | constraints.Float](start V, stop V, step V) []V
func Reduce[V any](slice []V, f func(V, V) (V, error)) (V, error)
func Remove[S ~[]V, V any](slice S, index int) S
func Repeat[V any](n int, v V) []V
func RepeatBy[V any](n int, f func(int) (V, error)) ([]V, error)
func Replace[S ~[]V, V comparable](slice S, old V, new V) S
func ReplaceAll[S ~[]V, V comparable](slice S, old V, new V) S
func Reverse[S ~[]V, V any](slice []V) S
func Sample[V any](slice []V, r *rand.Rand) V
func Shuffle[V any](slice []V, r *rand.Rand)
func Sliding[S ~[]V, V any](slice S, n int, step int) []S
func Span[S ~[]V, V comparable](slice S, v V) (S, S)
func SpanBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)
func Split[S ~[]V, V comparable](slice S, v V) (S, S)
func SplitAfter[S ~[]V, V comparable](slice S, v V) (S, S, error)
func SplitAfterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)
func SplitBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)
func StartsWith[V comparable](slice []V, subset []V) bool
func Sum[V constraints.Ordered | constraints.Complex](slice []V) V
func SumBy[V1 any, V2 constraints.Ordered | constraints.Complex](slice []V1, f func(V1) (V2, error)) (V2, error)
func Take[S ~[]V, V any](slice S, n int) S
func TakeWhile[S ~[]V, V comparable](slice S, v V) S
func TakeWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)
func ToIter[V any](slice []V) iter.Iter[V]
func ToMap[K comparable, V any](slice []tuple.T2[K, V]) map[K]V
func ToPtr[V any](slice []V) *V
func Unzip2[V1 any, V2 any](slice []tuple.T2[V1, V2]) ([]V1, []V2)
func Unzip3[V1 any, V2 any, V3 any](slice []tuple.T3[V1, V2, V3]) ([]V1, []V2, []V3)
func Unzip4[V1 any, V2 any, V3 any, V4 any](slice []tuple.T4[V1, V2, V3, V4]) ([]V1, []V2, []V3, []V4)
func Unzip5[V1 any, V2 any, V3 any, V4 any, V5 any](slice []tuple.T5[V1, V2, V3, V4, V5]) ([]V1, []V2, []V3, []V4, []V5)
func Unzip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](slice []tuple.T6[V1, V2, V3, V4, V5, V6]) ([]V1, []V2, []V3, []V4, []V5, []V6)
func Zip2[V1 any, V2 any](slice1 []V1, slice2 []V2) []tuple.T2[V1, V2]
func Zip3[V1 any, V2 any, V3 any](slice1 []V1, slice2 []V2, slice3 []V3) []tuple.T3[V1, V2, V3]
func Zip4[V1 any, V2 any, V3 any, V4 any](slice1 []V1, slice2 []V2, slice3 []V3, slice4 []V4) []tuple.T4[V1, V2, V3, V4]
func Zip5[V1 any, V2 any, V3 any, V4 any, V5 any](slice1 []V1, slice2 []V2, slice3 []V3, slice4 []V4, slice5 []V5) []tuple.T5[V1, V2, V3, V4, V5]
func Zip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](slice1 []V1, slice2 []V2, slice3 []V3, slice4 []V4, slice5 []V5, slice6 []V6) []tuple.T6[V1, V2, V3, V4, V5, V6]
func ZipWithIndex[V any](slice []V) []tuple.T2[V, int]

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func Append ¶

func Append[S ~[]V, V any](slice S, v ...V) S

スライスの末尾に値を追加する。

func Clean ¶

func Clean[S ~[]V, V comparable](slice S) S

ゼロ値を除いたスライスを返す。

func Clear ¶

func Clear[S ~[]V, V any](slice S) S

要素をすべて削除する。

func Clone ¶

func Clone[S ~[]V, V any](slice S) S

要素をすべてコピーしたスライスを返す。

func Collect ¶

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

条件を満たす値を変換したスライスを返す。

func Concat ¶

func Concat[S ~[]V, V any](slice1 S, slice2 []V) S

スライスの末尾に他のスライスを結合する。

func ContainsAll ¶

func ContainsAll[V comparable](slice []V, subset []V) bool

他のスライスの値がすべて存在していたらtrueを返す。

func ContainsAny ¶

func ContainsAny[V comparable](slice []V, subset []V) bool

他のスライスの値がひとつでも存在していたらtrueを返す。

func Count ¶

func Count[V comparable](slice []V, v V) int

一致する値の数を返す。

func CountBy ¶

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

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

func Distinct ¶

func Distinct[S ~[]V, V comparable](slice S) S

重複を除いたスライスを返す。

func Drop ¶

func Drop[S ~[]V, V any](slice S, n int) S

先頭n個の値を除いたスライスを返す。

func DropWhile ¶

func DropWhile[S ~[]V, V comparable](slice S, v V) S

一致し続ける先頭の値を除いたスライスを返す。

func DropWhileBy ¶

func DropWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)

条件を満たし続ける先頭の値を除いたスライスを返す。

func EndsWith ¶

func EndsWith[V comparable](slice []V, subset []V) bool

終端が他のスライスと一致していたらtrueを返す。

func Equal ¶

func Equal[V comparable](slice1 []V, slice2 []V) bool

他のスライスと一致していたらtrueを返す。

func EqualBy ¶

func EqualBy[V any](slice1 []V, slice2 []V, f func(V, V) (bool, error)) (bool, error)

他のスライスと関数で比較し、一致していたらtrueを返す。

func Exists ¶

func Exists[V comparable](slice []V, v V) bool

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

func ExistsBy ¶

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

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

func Fill ¶

func Fill[V any](slice []V, v V)

すべての要素に値を代入する。

func FillBy ¶

func FillBy[V any](slice []V, f func(int) (V, error)) error

すべての要素に関数の実行結果を代入する。

func FillZero ¶

func FillZero[V any](slice []V)

すべての要素にゼロ値を代入する。

func Filter ¶

func Filter[S ~[]V, V comparable](slice S, v V) S

一致する値だけのスライスを返す。

func FilterBy ¶

func FilterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)

条件を満たす値だけのスライスを返す。

func FilterNot ¶

func FilterNot[S ~[]V, V comparable](slice S, v V) S

一致する値を除いたスライスを返す。

func FilterNotBy ¶

func FilterNotBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)

条件を満たす値を除いたスライスを返す。

func Find ¶

func Find[V comparable](slice []V, v V) (V, bool)

一致する値を返す。

func FindBy ¶

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

条件を満たす値を返す。

func FlatMap ¶

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

値をスライスに変換し、それらを結合したスライスを返す。

func Flatten ¶

func Flatten[S ~[]V, V any](slice []S) S

平坦化したスライスを返す。

func Fold ¶

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

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

func ForAll ¶

func ForAll[V comparable](slice []V, v V) bool

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

func ForAllBy ¶

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

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

func ForEach ¶

func ForEach[V any](slice []V, f func(V) error) error

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

func From ¶

func From[T any](values ...T) []T

値からスライスをつくる。

func FromIter ¶

func FromIter[V any](iter iter.Iter[V]) []V

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

func FromMap ¶

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

マップからスライスをつくる。

func FromMapKeys ¶

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

マップのキーをスライスをつくる。

func FromMapValues ¶

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

マップの値をスライスをつくる。

func FromPtr ¶

func FromPtr[T any](v *T) []T

ポインタからスライスをつくる。

func Get ¶

func Get[V any](slice []V, index int) (V, bool)

指定した位置の要素を返す。

func GetFirst ¶

func GetFirst[V any](slice []V) (V, bool)

先頭の要素を返す。

func GetFirstOrElse ¶

func GetFirstOrElse[V any](slice []V, v V) V

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

func GetLast ¶

func GetLast[V any](slice []V) (V, bool)

終端の要素を返す。

func GetLastOrElse ¶

func GetLastOrElse[V any](slice []V, v V) V

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

func GetOrElse ¶

func GetOrElse[V any](slice []V, index int, v V) V

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

func GetOrFunc ¶ added in v0.0.3

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

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

func GetOrNil ¶ added in v0.0.6

func GetOrNil[V any](slice []V, index int) *V

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

func GetOrZero ¶ added in v0.0.6

func GetOrZero[V any](slice []V, index int) V

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

func GroupBy ¶

func GroupBy[S ~[]V, K comparable, V any](slice S, f func(V) (K, error)) (map[K]S, error)

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

func Grouped ¶ added in v0.0.6

func Grouped[S ~[]V, V any](slice S, n int) []S

n個ごとのスライスを返す。

func Index ¶

func Index[V comparable](slice []V, v V) int

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

func IndexBy ¶

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

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

func Indices ¶

func Indices[V any](slice []V) []int

位置のスライスを返す。

func Insert ¶

func Insert[S ~[]V, V any](slice S, index int, v ...V) S

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

func IsEmpty ¶ added in v0.0.5

func IsEmpty[V any](slice []V) bool

空のときtrueを返す。

func Join ¶

func Join[S ~[]V, V any](slice S, separator V) S

値のあいだにseparatorを挿入したスライスを返す。

func LastIndex ¶

func LastIndex[V comparable](slice []V, v V) int

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

func LastIndexBy ¶

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

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

func Len ¶

func Len[V any](slice []V) int

値の数を返す。

func Map ¶

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

値を変換したスライスを返す。

func Max ¶

func Max[V constraints.Ordered](slice []V) V

最大の値を返す。

func MaxBy ¶

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

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

func Min ¶

func Min[V constraints.Ordered](slice []V) V

最小の値を返す。

func MinBy ¶

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

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

func MustCollect ¶ added in v0.0.5

func MustCollect[V1 any, V2 any](slice []V1, f func(V1) (V2, bool, error)) []V2

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

func MustCountBy ¶ added in v0.0.5

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

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

func MustDropWhileBy ¶ added in v0.0.5

func MustDropWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S

条件を満たし続ける先頭の値を除いたスライスを返す。実行中にエラーが起きた場合 panic する。

func MustEqualBy ¶ added in v0.0.5

func MustEqualBy[V any](slice1 []V, slice2 []V, f func(V, V) (bool, error)) bool

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

func MustExistsBy ¶ added in v0.0.5

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

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

func MustFilterBy ¶ added in v0.0.5

func MustFilterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S

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

func MustFilterNotBy ¶ added in v0.0.5

func MustFilterNotBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S

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

func MustFindBy ¶ added in v0.0.5

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

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

func MustFlatMap ¶ added in v0.0.5

func MustFlatMap[V1, V2 any](slice []V1, f func(V1) ([]V2, error)) []V2

値をスライスに変換し、それらを結合したスライスを返す。

func MustFold ¶ added in v0.0.5

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

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

func MustForAllBy ¶ added in v0.0.5

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

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

func MustForEach ¶ added in v0.0.5

func MustForEach[V any](slice []V, f func(V) error)

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

func MustGetOrFunc ¶ added in v0.0.5

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

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

func MustGroupBy ¶ added in v0.0.5

func MustGroupBy[S ~[]V, K comparable, V any](slice S, f func(V) (K, error)) map[K]S

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

func MustIndexBy ¶ added in v0.0.5

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

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

func MustLastIndexBy ¶ added in v0.0.5

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

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

func MustMap ¶ added in v0.0.5

func MustMap[V1 any, V2 any](slice []V1, f func(V1) (V2, error)) []V2

値を変換したスライスを返す。実行中にエラーが起きた場合 panic する。

func MustMaxBy ¶ added in v0.0.5

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

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

func MustMinBy ¶ added in v0.0.5

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

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

func MustPadBy ¶ added in v0.0.5

func MustPadBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) S

要素がn個になるまで先頭に関数の実行結果を挿入する。

func MustPadRightBy ¶ added in v0.0.5

func MustPadRightBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) S

要素がn個になるまで末尾に関数の実行結果を挿入する。

func MustPartitionBy ¶ added in v0.0.5

func MustPartitionBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)

条件を満たすスライスと満たさないスライスを返す。

func MustReduce ¶ added in v0.0.5

func MustReduce[V any](slice []V, f func(V, V) (V, error)) V

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

func MustSpanBy ¶ added in v0.0.5

func MustSpanBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)

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

func MustSplitAfter ¶ added in v0.0.5

func MustSplitAfter[S ~[]V, V comparable](slice S, v V) (S, S)

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

func MustSplitAfterBy ¶ added in v0.0.5

func MustSplitAfterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)

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

func MustSplitBy ¶ added in v0.0.5

func MustSplitBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S)

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

func MustSumBy ¶ added in v0.0.5

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

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

func MustTakeWhileBy ¶ added in v0.0.5

func MustTakeWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) S

条件を満たし続ける先頭の値のスライスを返す。実行中にエラーが起きた場合 panic する。

func Option ¶

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

値と値の有無を受け取ってスライスをつくる。

func Pad ¶

func Pad[S ~[]V, V any](slice S, n int, v V) S

要素がn個になるまで先頭にvを挿入する。

func PadBy ¶

func PadBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) (S, error)

要素がn個になるまで先頭に関数の実行結果を挿入する。

func PadRight ¶

func PadRight[S ~[]V, V any](slice S, n int, v V) S

要素がn個になるまで末尾にvを挿入する。

func PadRightBy ¶

func PadRightBy[S ~[]V, V any](slice S, n int, f func(int) (V, error)) (S, error)

要素がn個になるまで末尾に関数の実行結果を挿入する。

func PadZero ¶

func PadZero[S ~[]V, V any](slice S, n int) S

要素がn個になるまで先頭にゼロ値を挿入する。

func PadZeroRight ¶

func PadZeroRight[S ~[]V, V any](slice S, n int) S

要素がn個になるまで末尾にゼロ値を挿入する。

func Partition ¶

func Partition[S ~[]V, V comparable](slice S, v V) (S, S)

値の一致するスライスと一致しないスライスを返す。

func PartitionBy ¶

func PartitionBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)

条件を満たすスライスと満たさないスライスを返す。

func Range ¶

func Range[V constraints.Integer | constraints.Float](start V, stop V, step V) []V

範囲を指定してスライスをつくる。

func Reduce ¶

func Reduce[V any](slice []V, f func(V, V) (V, error)) (V, error)

値を順に演算する。

func Remove ¶

func Remove[S ~[]V, V any](slice S, index int) S

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

func Repeat ¶

func Repeat[V any](n int, v V) []V

指定した値をn個複製してスライスをつくる。

func RepeatBy ¶

func RepeatBy[V any](n int, f func(int) (V, error)) ([]V, error)

指定した値をn個複製してスライスをつくる。

func Replace ¶

func Replace[S ~[]V, V comparable](slice S, old V, new V) S

ひとつめのoldをnewで置き換えたスライスを返す。

func ReplaceAll ¶

func ReplaceAll[S ~[]V, V comparable](slice S, old V, new V) S

すべてのoldをnewで置き換えたスライスを返す。

func Reverse ¶

func Reverse[S ~[]V, V any](slice []V) S

逆順にしたスライスを返す。

func Sample ¶

func Sample[V any](slice []V, r *rand.Rand) V

要素を１つランダムに返す。

func Shuffle ¶

func Shuffle[V any](slice []V, r *rand.Rand)

要素をランダムに入れ替える。

func Sliding ¶ added in v0.0.6

func Sliding[S ~[]V, V any](slice S, n int, step int) []S

stepずつズラしたn個ごとのスライスを返す。

func Span ¶

func Span[S ~[]V, V comparable](slice S, v V) (S, S)

一致し続ける先頭部分と残りの部分、ふたつのスライスを返す。

func SpanBy ¶

func SpanBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)

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

func Split ¶

func Split[S ~[]V, V comparable](slice S, v V) (S, S)

一致する値の直前で分割したふたつのスライスを返す。

func SplitAfter ¶

func SplitAfter[S ~[]V, V comparable](slice S, v V) (S, S, error)

一致する値の直後で分割したふたつのスライスを返す。

func SplitAfterBy ¶

func SplitAfterBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)

条件を満たす値の直後で分割したふたつのスライスを返す。

func SplitBy ¶

func SplitBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, S, error)

条件を満たす値の直前で分割したふたつのスライスを返す。

func StartsWith ¶

func StartsWith[V comparable](slice []V, subset []V) bool

先頭が他のスライスと一致していたらtrueを返す。

func Sum ¶

func Sum[V constraints.Ordered | constraints.Complex](slice []V) V

値の合計を演算する。

func SumBy ¶

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

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

func Take ¶

func Take[S ~[]V, V any](slice S, n int) S

先頭n個の値のスライスを返す。

func TakeWhile ¶

func TakeWhile[S ~[]V, V comparable](slice S, v V) S

一致し続ける先頭の値のスライスを返す。

func TakeWhileBy ¶

func TakeWhileBy[S ~[]V, V any](slice S, f func(V) (bool, error)) (S, error)

条件を満たし続ける先頭の値のスライスを返す。

func ToIter ¶

func ToIter[V any](slice []V) iter.Iter[V]

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

func ToMap ¶

func ToMap[K comparable, V any](slice []tuple.T2[K, V]) map[K]V

キーと値のペアのスライスからマップをつくる。

func ToPtr ¶

func ToPtr[V any](slice []V) *V

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

func Unzip2 ¶

func Unzip2[V1 any, V2 any](slice []tuple.T2[V1, V2]) ([]V1, []V2)

値のペアを分離して２つのスライスを返す。

func Unzip3 ¶

func Unzip3[V1 any, V2 any, V3 any](slice []tuple.T3[V1, V2, V3]) ([]V1, []V2, []V3)

値のペアを分離して３つのスライスを返す。

func Unzip4 ¶

func Unzip4[V1 any, V2 any, V3 any, V4 any](slice []tuple.T4[V1, V2, V3, V4]) ([]V1, []V2, []V3, []V4)

値のペアを分離して４つのスライスを返す。

func Unzip5 ¶

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

値のペアを分離して５つのスライスを返す。

func Unzip6 ¶

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

値のペアを分離して６つのスライスを返す。

func Zip2 ¶

func Zip2[V1 any, V2 any](slice1 []V1, slice2 []V2) []tuple.T2[V1, V2]

２つのスライスの同じ位置の値をペアにしたスライスを返す。

func Zip3 ¶

func Zip3[V1 any, V2 any, V3 any](slice1 []V1, slice2 []V2, slice3 []V3) []tuple.T3[V1, V2, V3]

３つのスライスの同じ位置の値をペアにしたスライスを返す。

func Zip4 ¶

func Zip4[V1 any, V2 any, V3 any, V4 any](slice1 []V1, slice2 []V2, slice3 []V3, slice4 []V4) []tuple.T4[V1, V2, V3, V4]

４つのスライスの同じ位置の値をペアにしたスライスを返す。

func Zip5 ¶

func Zip5[V1 any, V2 any, V3 any, V4 any, V5 any](slice1 []V1, slice2 []V2, slice3 []V3, slice4 []V4, slice5 []V5) []tuple.T5[V1, V2, V3, V4, V5]

５つのスライスの同じ位置の値をペアにしたスライスを返す。

func Zip6 ¶

func Zip6[V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](slice1 []V1, slice2 []V2, slice3 []V3, slice4 []V4, slice5 []V5, slice6 []V6) []tuple.T6[V1, V2, V3, V4, V5, V6]

６つのスライスの同じ位置の値をペアにしたスライスを返す。

func ZipWithIndex ¶

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

値と位置をペアにしたスライスを返す。

Types ¶

This section is empty.

Source Files ¶

View all Source files

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