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

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 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