maps

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
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/thamaji/gu

Links

Open Source Insights

Documentation ¶

Index ¶

func Clean[M ~map[K]V, K comparable, V comparable](m M) M
func Clear[K comparable, V any](m map[K]V) map[K]V
func Clone[M ~map[K]V, K comparable, V any](m M) M
func Collect[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, bool, error)) (map[K]V2, error)
func Count[K comparable, V comparable](m map[K]V, v V) int
func CountBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (int, error)
func Distinct[M ~map[K]V, K comparable, V comparable](m M) M
func Equal[K comparable, V comparable](m1 map[K]V, m2 map[K]V) bool
func EqualBy[K comparable, V any](m1 map[K]V, m2 map[K]V, f func(V, V) (bool, error)) (bool, error)
func Exists[K comparable, V comparable](m map[K]V, v V) bool
func ExistsBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (bool, error)
func Fill[K comparable, V any](m map[K]V, v V)
func FillBy[K comparable, V any](m map[K]V, f func(K) (V, error)) error
func FillZero[K comparable, V any](m map[K]V)
func Filter[M ~map[K]V, K comparable, V comparable](m M, v V) M
func FilterBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, error)
func FilterNot[M ~map[K]V, K comparable, V comparable](m M, v V) M
func FilterNotBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, error)
func Find[K comparable, V comparable](m map[K]V, v V) (V, bool)
func FindBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (V, bool, error)
func Fold[K comparable, V1 any, V2 any](m map[K]V1, v V2, f func(V2, K, V1) (V2, error)) (V2, error)
func ForAll[K comparable, V comparable](m map[K]V, v V) bool
func ForAllBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (bool, error)
func ForEach[K comparable, V any](m map[K]V, f func(K, V) error) error
func From[K comparable, V any](tuples ...tuple.T2[K, V]) map[K]V
func FromIter[K comparable, V any](iter iter.Iter[tuple.T2[K, V]]) map[K]V
func Get[K comparable, V any](m map[K]V, k K) (V, bool)
func GetOrElse[K comparable, V any](m map[K]V, k K, v V) V
func GetOrFunc[K comparable, V any](m map[K]V, k K, f func() (V, error)) (V, error)
func GetOrNil[K comparable, V any](m map[K]V, k K) *V
func GetOrZero[K comparable, V any](m map[K]V, k K) V
func GroupBy[K1 comparable, K2 comparable, V any](m map[K1]V, f func(K1, V) (K2, error)) (map[K2][]V, error)
func IsEmpty[K comparable, V any](m map[K]V) bool
func Keys[K comparable, V any](m map[K]V) []K
func Len[K comparable, V any](m map[K]V) int
func Map[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, error)) (map[K]V2, error)
func Max[K comparable, V constraints.Ordered](m map[K]V) V
func MaxBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) (V2, error)
func Min[K comparable, V constraints.Ordered](m map[K]V) V
func MinBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) (V2, error)
func MustCollect[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, bool, error)) map[K]V2
func MustCountBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) int
func MustEqualBy[K comparable, V any](m1 map[K]V, m2 map[K]V, f func(V, V) (bool, error)) bool
func MustExistsBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) bool
func MustFilterBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) M
func MustFilterNotBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) M
func MustFindBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (V, bool)
func MustFold[K comparable, V1 any, V2 any](m map[K]V1, v V2, f func(V2, K, V1) (V2, error)) V2
func MustForAllBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) bool
func MustForEach[K comparable, V any](m map[K]V, f func(K, V) error)
func MustGetOrFunc[K comparable, V any](m map[K]V, k K, f func() (V, error)) V
func MustGroupBy[K1 comparable, K2 comparable, V any](m map[K1]V, f func(K1, V) (K2, error)) map[K2][]V
func MustMap[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, error)) map[K]V2
func MustMaxBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) V2
func MustMinBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) V2
func MustPartitionBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, M)
func MustPutBy[K comparable, V any](m map[K]V, k K, f func(V, bool) (V, error)) V
func MustPutIfEmptyBy[K comparable, V any](m map[K]V, k K, f func() (V, error)) V
func MustReduce[K comparable, V any](m map[K]V, f func(V, K, V) (V, error)) V
func MustSumBy[K comparable, V1 any, V2 constraints.Ordered | constraints.Complex](m map[K]V1, f func(K, V1) (V2, error)) V2
func Partition[M ~map[K]V, K comparable, V comparable](m M, v V) (M, M)
func PartitionBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, M, error)
func Put[K comparable, V any](m map[K]V, k K, v V) V
func PutBy[K comparable, V any](m map[K]V, k K, f func(V, bool) (V, error)) (V, error)
func PutIfEmpty[K comparable, V any](m map[K]V, k K, v V) V
func PutIfEmptyBy[K comparable, V any](m map[K]V, k K, f func() (V, error)) (V, error)
func Reduce[K comparable, V any](m map[K]V, f func(V, K, V) (V, error)) (V, error)
func Replace[M ~map[K]V, K comparable, V comparable](m M, old V, new V) M
func ReplaceAll[M ~map[K]V, K comparable, V comparable](m M, old V, new V) M
func Sample[K comparable, V any](m map[K]V, r *rand.Rand) V
func Sum[K comparable, V constraints.Ordered | constraints.Complex](m map[K]V) V
func SumBy[K comparable, V1 any, V2 constraints.Ordered | constraints.Complex](m map[K]V1, f func(K, V1) (V2, error)) (V2, error)
func ToIter[K comparable, V any](m map[K]V) iter.Iter[tuple.T2[K, V]]
func ToSlice[K comparable, V any](m map[K]V) []tuple.T2[K, V]
func Unzip2[K comparable, V1 any, V2 any](m map[K]tuple.T2[V1, V2]) (map[K]V1, map[K]V2)
func Unzip3[K comparable, V1 any, V2 any, V3 any](m map[K]tuple.T3[V1, V2, V3]) (map[K]V1, map[K]V2, map[K]V3)
func Unzip4[K comparable, V1 any, V2 any, V3 any, V4 any](m map[K]tuple.T4[V1, V2, V3, V4]) (map[K]V1, map[K]V2, map[K]V3, map[K]V4)
func Unzip5[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any](m map[K]tuple.T5[V1, V2, V3, V4, V5]) (map[K]V1, map[K]V2, map[K]V3, map[K]V4, map[K]V5)
func Unzip6[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](m map[K]tuple.T6[V1, V2, V3, V4, V5, V6]) (map[K]V1, map[K]V2, map[K]V3, map[K]V4, map[K]V5, map[K]V6)
func Values[K comparable, V any](m map[K]V) []V
func Zip2[K comparable, V1 any, V2 any](m1 map[K]V1, m2 map[K]V2) map[K]tuple.T2[V1, V2]
func Zip3[K comparable, V1 any, V2 any, V3 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3) map[K]tuple.T3[V1, V2, V3]
func Zip4[K comparable, V1 any, V2 any, V3 any, V4 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3, m4 map[K]V4) map[K]tuple.T4[V1, V2, V3, V4]
func Zip5[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3, m4 map[K]V4, m5 map[K]V5) map[K]tuple.T5[V1, V2, V3, V4, V5]
func Zip6[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3, m4 map[K]V4, m5 map[K]V5, m6 map[K]V6) map[K]tuple.T6[V1, V2, V3, V4, V5, V6]

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func Clean ¶

func Clean[M ~map[K]V, K comparable, V comparable](m M) M

ゼロ値を除いたマップを返す。

func Clear ¶

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

要素をすべて削除する。

func Clone ¶

func Clone[M ~map[K]V, K comparable, V any](m M) M

要素をすべてコピーしたマップを返す。

func Collect ¶

func Collect[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, bool, error)) (map[K]V2, error)

条件を満たす値を変換したマップを返す。

func Count ¶

func Count[K comparable, V comparable](m map[K]V, v V) int

一致する値の数を返す。

func CountBy ¶

func CountBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (int, error)

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

func Distinct ¶

func Distinct[M ~map[K]V, K comparable, V comparable](m M) M

重複を除いたマップを返す。

func Equal ¶

func Equal[K comparable, V comparable](m1 map[K]V, m2 map[K]V) bool

他のマップと一致していたらtrueを返す。

func EqualBy ¶

func EqualBy[K comparable, V any](m1 map[K]V, m2 map[K]V, f func(V, V) (bool, error)) (bool, error)

他のマップと関数で比較し、一致していたらtrueを返す。

func Exists ¶

func Exists[K comparable, V comparable](m map[K]V, v V) bool

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

func ExistsBy ¶

func ExistsBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (bool, error)

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

func Fill ¶

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

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

func FillBy ¶

func FillBy[K comparable, V any](m map[K]V, f func(K) (V, error)) error

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

func FillZero ¶

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

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

func Filter ¶

func Filter[M ~map[K]V, K comparable, V comparable](m M, v V) M

一致する値だけのマップを返す。

func FilterBy ¶

func FilterBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, error)

条件を満たす値だけのマップを返す。

func FilterNot ¶

func FilterNot[M ~map[K]V, K comparable, V comparable](m M, v V) M

一致する値を除いたマップを返す。

func FilterNotBy ¶

func FilterNotBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, error)

条件を満たす値を除いたマップを返す。

func Find ¶

func Find[K comparable, V comparable](m map[K]V, v V) (V, bool)

一致する値を返す。

func FindBy ¶

func FindBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (V, bool, error)

条件を満たす値を返す。

func Fold ¶

func Fold[K comparable, V1 any, V2 any](m map[K]V1, v V2, f func(V2, K, V1) (V2, error)) (V2, error)

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

func ForAll ¶

func ForAll[K comparable, V comparable](m map[K]V, v V) bool

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

func ForAllBy ¶

func ForAllBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (bool, error)

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

func ForEach ¶

func ForEach[K comparable, V any](m map[K]V, f func(K, V) error) error

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

func From ¶

func From[K comparable, V any](tuples ...tuple.T2[K, V]) map[K]V

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

func FromIter ¶

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

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

func Get ¶

func Get[K comparable, V any](m map[K]V, k K) (V, bool)

指定したキーの値を返す。

func GetOrElse ¶

func GetOrElse[K comparable, V any](m map[K]V, k K, v V) V

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

func GetOrFunc ¶ added in v0.0.3

func GetOrFunc[K comparable, V any](m map[K]V, k K, f func() (V, error)) (V, error)

指定したキーの値を返す。無い場合は関数の実行結果を返す。

func GetOrNil ¶ added in v0.0.6

func GetOrNil[K comparable, V any](m map[K]V, k K) *V

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

func GetOrZero ¶ added in v0.0.6

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

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

func GroupBy ¶

func GroupBy[K1 comparable, K2 comparable, V any](m map[K1]V, f func(K1, V) (K2, error)) (map[K2][]V, error)

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

func IsEmpty ¶ added in v0.0.5

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

空のときtrueを返す。

func Keys ¶

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

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

func Len ¶

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

値の数を返す。

func Map ¶

func Map[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, error)) (map[K]V2, error)

値を変換したマップを返す。

func Max ¶

func Max[K comparable, V constraints.Ordered](m map[K]V) V

最大の値を返す。

func MaxBy ¶

func MaxBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) (V2, error)

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

func Min ¶

func Min[K comparable, V constraints.Ordered](m map[K]V) V

最小の値を返す。

func MinBy ¶

func MinBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) (V2, error)

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

func MustCollect ¶ added in v0.0.5

func MustCollect[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, bool, error)) map[K]V2

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

func MustCountBy ¶ added in v0.0.5

func MustCountBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) int

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

func MustEqualBy ¶ added in v0.0.5

func MustEqualBy[K comparable, V any](m1 map[K]V, m2 map[K]V, f func(V, V) (bool, error)) bool

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

func MustExistsBy ¶ added in v0.0.5

func MustExistsBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) bool

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

func MustFilterBy ¶ added in v0.0.5

func MustFilterBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) M

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

func MustFilterNotBy ¶ added in v0.0.5

func MustFilterNotBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) M

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

func MustFindBy ¶ added in v0.0.5

func MustFindBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (V, bool)

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

func MustFold ¶ added in v0.0.5

func MustFold[K comparable, V1 any, V2 any](m map[K]V1, v V2, f func(V2, K, V1) (V2, error)) V2

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

func MustForAllBy ¶ added in v0.0.5

func MustForAllBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) bool

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

func MustForEach ¶ added in v0.0.5

func MustForEach[K comparable, V any](m map[K]V, f func(K, V) error)

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

func MustGetOrFunc ¶ added in v0.0.5

func MustGetOrFunc[K comparable, V any](m map[K]V, k K, f func() (V, error)) V

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

func MustGroupBy ¶ added in v0.0.5

func MustGroupBy[K1 comparable, K2 comparable, V any](m map[K1]V, f func(K1, V) (K2, error)) map[K2][]V

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

func MustMap ¶ added in v0.0.5

func MustMap[K comparable, V1 any, V2 any](m map[K]V1, f func(K, V1) (V2, error)) map[K]V2

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

func MustMaxBy ¶ added in v0.0.5

func MustMaxBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) V2

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

func MustMinBy ¶ added in v0.0.5

func MustMinBy[K comparable, V1 any, V2 constraints.Ordered](m map[K]V1, f func(K, V1) (V2, error)) V2

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

func MustPartitionBy ¶ added in v0.0.5

func MustPartitionBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, M)

条件を満たすマップと満たさないマップを返す。実行中にエラーが起きた場合 panic する。

func MustPutBy ¶ added in v0.0.16

func MustPutBy[K comparable, V any](m map[K]V, k K, f func(V, bool) (V, error)) V

指定したキーの値を関数の実行結果で更新する。実行中にエラーが起きた場合 panic する。関数はもとの値と値が存在するかを受け取り、更新後の値を返す。

func MustPutIfEmptyBy ¶ added in v0.0.16

func MustPutIfEmptyBy[K comparable, V any](m map[K]V, k K, f func() (V, error)) V

指定したキーが空のとき、関数の実行結果で値を更新する。実行中にエラーが起きた場合 panic する。

func MustReduce ¶ added in v0.0.5

func MustReduce[K comparable, V any](m map[K]V, f func(V, K, V) (V, error)) V

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

func MustSumBy ¶ added in v0.0.5

func MustSumBy[K comparable, V1 any, V2 constraints.Ordered | constraints.Complex](m map[K]V1, f func(K, V1) (V2, error)) V2

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

func Partition ¶

func Partition[M ~map[K]V, K comparable, V comparable](m M, v V) (M, M)

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

func PartitionBy ¶

func PartitionBy[M ~map[K]V, K comparable, V any](m M, f func(K, V) (bool, error)) (M, M, error)

条件を満たすマップと満たさないマップを返す。

func Put ¶ added in v0.0.16

func Put[K comparable, V any](m map[K]V, k K, v V) V

指定したキーの値を更新する。

func PutBy ¶ added in v0.0.16

func PutBy[K comparable, V any](m map[K]V, k K, f func(V, bool) (V, error)) (V, error)

指定したキーの値を関数の実行結果で更新する。関数はもとの値と値が存在するかを受け取り、更新後の値を返す。

func PutIfEmpty ¶ added in v0.0.16

func PutIfEmpty[K comparable, V any](m map[K]V, k K, v V) V

指定したキーが空のとき、値を更新する。

func PutIfEmptyBy ¶ added in v0.0.16

func PutIfEmptyBy[K comparable, V any](m map[K]V, k K, f func() (V, error)) (V, error)

指定したキーが空のとき、関数の実行結果で値を更新する。

func Reduce ¶

func Reduce[K comparable, V any](m map[K]V, f func(V, K, V) (V, error)) (V, error)

値を順に演算する。

func Replace ¶

func Replace[M ~map[K]V, K comparable, V comparable](m M, old V, new V) M

ひとつめのoldをnewで置き換えたマップを返す。

func ReplaceAll ¶

func ReplaceAll[M ~map[K]V, K comparable, V comparable](m M, old V, new V) M

すべてのoldをnewで置き換えたマップを返す。

func Sample ¶

func Sample[K comparable, V any](m map[K]V, r *rand.Rand) V

値を１つランダムに返す。

func Sum ¶

func Sum[K comparable, V constraints.Ordered | constraints.Complex](m map[K]V) V

値の合計を返す。

func SumBy ¶

func SumBy[K comparable, V1 any, V2 constraints.Ordered | constraints.Complex](m map[K]V1, f func(K, V1) (V2, error)) (V2, error)

値を変換して合計を返す。

func ToIter ¶

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

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

func ToSlice ¶

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

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

func Unzip2 ¶

func Unzip2[K comparable, V1 any, V2 any](m map[K]tuple.T2[V1, V2]) (map[K]V1, map[K]V2)

値のペアを分離して２つのマップを返す。

func Unzip3 ¶

func Unzip3[K comparable, V1 any, V2 any, V3 any](m map[K]tuple.T3[V1, V2, V3]) (map[K]V1, map[K]V2, map[K]V3)

値のペアを分離して３つのマップを返す。

func Unzip4 ¶

func Unzip4[K comparable, V1 any, V2 any, V3 any, V4 any](m map[K]tuple.T4[V1, V2, V3, V4]) (map[K]V1, map[K]V2, map[K]V3, map[K]V4)

値のペアを分離して４つのマップを返す。

func Unzip5 ¶

func Unzip5[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any](m map[K]tuple.T5[V1, V2, V3, V4, V5]) (map[K]V1, map[K]V2, map[K]V3, map[K]V4, map[K]V5)

値のペアを分離して５つのマップを返す。

func Unzip6 ¶

func Unzip6[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](m map[K]tuple.T6[V1, V2, V3, V4, V5, V6]) (map[K]V1, map[K]V2, map[K]V3, map[K]V4, map[K]V5, map[K]V6)

値のペアを分離して５つのマップを返す。

func Values ¶

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

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

func Zip2 ¶

func Zip2[K comparable, V1 any, V2 any](m1 map[K]V1, m2 map[K]V2) map[K]tuple.T2[V1, V2]

２つのマップの同じキーの値をペアにしたマップを返す。

func Zip3 ¶

func Zip3[K comparable, V1 any, V2 any, V3 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3) map[K]tuple.T3[V1, V2, V3]

３つのマップの同じキーの値をペアにしたマップを返す。

func Zip4 ¶

func Zip4[K comparable, V1 any, V2 any, V3 any, V4 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3, m4 map[K]V4) map[K]tuple.T4[V1, V2, V3, V4]

４つのマップの同じキーの値をペアにしたマップを返す。

func Zip5 ¶

func Zip5[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3, m4 map[K]V4, m5 map[K]V5) map[K]tuple.T5[V1, V2, V3, V4, V5]

５つのマップの同じキーの値をペアにしたマップを返す。

func Zip6 ¶

func Zip6[K comparable, V1 any, V2 any, V3 any, V4 any, V5 any, V6 any](m1 map[K]V1, m2 map[K]V2, m3 map[K]V3, m4 map[K]V4, m5 map[K]V5, m6 map[K]V6) map[K]tuple.T6[V1, V2, V3, V4, V5, V6]

６つのマップの同じキーの値をペアにしたマップを返す。

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