slices

package

v0.0.15 Latest Latest Go to latest Published: Feb 9, 2024 License: MIT Imports: 5 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 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