maps

Documentation

Index

• func Clean[K comparable, V comparable](m map[K]V) map[K]V
• func Clear[K comparable, V any](m map[K]V) map[K]V
• func Clone[K comparable, V any](m map[K]V) map[K]V
• 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[K comparable, V comparable](m map[K]V) map[K]V
• 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[K comparable, V comparable](m map[K]V, v V) map[K]V
• func FilterBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (map[K]V, error)
• func FilterNot[K comparable, V comparable](m map[K]V, v V) map[K]V
• func FilterNotBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (map[K]V, 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[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) map[K]V
• func MustFilterNotBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) map[K]V
• 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[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (map[K]V, map[K]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[K comparable, V comparable](m map[K]V, v V) (map[K]V, map[K]V)
• func PartitionBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (map[K]V, map[K]V, error)
• func Reduce[K comparable, V any](m map[K]V, f func(V, K, V) (V, error)) (V, error)
• func Replace[K comparable, V comparable](m map[K]V, old V, new V) map[K]V
• func ReplaceAll[K comparable, V comparable](m map[K]V, old V, new V) map[K]V
• 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]

Functions

func Clean

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

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

func Clear

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

要素をすべて削除する。

func Clone

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

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

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[K comparable, V comparable](m map[K]V) map[K]V

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

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[K comparable, V comparable](m map[K]V, v V) map[K]V

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

func FilterBy

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

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

func FilterNot

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

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

func FilterNotBy

func FilterNotBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (map[K]V, 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

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

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

func GetOrNil

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

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

func GetOrZero

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

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

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

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

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

func MustEqualBy

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

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

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

func MustFilterBy

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

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

func MustFilterNotBy

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

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

func MustFindBy

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

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

func MustFold

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

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

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

func MustForEach

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

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

func MustGetOrFunc

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

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

func MustGroupBy

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

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

func MustMap

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

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

func MustMaxBy

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

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

func MustMinBy

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

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

func MustPartitionBy

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

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

func MustReduce

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

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

func MustSumBy

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[K comparable, V comparable](m map[K]V, v V) (map[K]V, map[K]V)

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

func PartitionBy

func PartitionBy[K comparable, V any](m map[K]V, f func(K, V) (bool, error)) (map[K]V, map[K]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[K comparable, V comparable](m map[K]V, old V, new V) map[K]V

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

func ReplaceAll

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

すべての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]

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