std:map リファレンス

import map := 'std:map' で取得する順序付きマップモジュール。キー昇順の SortedMap と挿入順の InsertionMap を提供する。

insertion

insertion
insertion: { empty: InsertionMap, of: { List | InsertionMap } |}

InsertionMap (挿入順マップ) のコンストラクタをまとめた名前空間。

>>> map.insertion.empty
InsertionMap{}

sorted

sorted
sorted: { empty: SortedMap, of: { List | SortedMap } |}

SortedMap (キー昇順マップ) のコンストラクタをまとめた名前空間。

>>> map.sorted.empty.is_empty!
true

InsertionMap メソッド

each

m.each { k, v | … }
each: { Any | Unit }

挿入順に各エントリへ適用する。

>>> map.insertion.of([("b", 2), ("a", 1)]).each { k, v | println(k, v) }
("b", 2)
("a", 1)

entries

m.entries!
entries: { List(Any) }

(key, value) の挿入順 List。

>>> map.insertion.of([("b", 2), ("a", 1)]).entries!
[("b", 2), ("a", 1)]

filter

m.filter { k, v | Bool }
filter: { Any | InsertionMap }

述語が true のエントリだけの新 InsertionMap (順序保存)。

>>> map.insertion.of([("a", 1), ("b", 2)]).filter { k, v | v > 1 }
InsertionMap{"b": 2}

first

m.first!
first: { Option(Any) }

先頭 (最初に挿入された) エントリを Some((k, v))、空なら None。

>>> map.insertion.of([("b", 2), ("a", 1)]).first!
Some(("b", 2))

fold

m.fold(init) { acc, k, v | … }
fold: { Any, Any | Any }

挿入順の左畳み込み。

>>> map.insertion.of([("a", 1), ("b", 2)]).fold(0) { acc, k, v | acc + v }
3

get

m.get(k)
get: { Any | Option(Any) }

キー k の値を Some(v)、無ければ None。

>>> map.insertion.of([("a", 1)]).get("a")
Some(1)

has

m.has(k)
has: { Any | Bool }

キー k が存在すれば true。

>>> map.insertion.of([("a", 1)]).has("a")
true

insert

m.insert(k, v)
insert: { Any, Any | InsertionMap }

k→v を加えた新 InsertionMap (既存キーは位置維持で更新・新規は末尾)。

>>> map.insertion.of([("a", 1)]).insert("b", 2)
InsertionMap{"a": 1, "b": 2}

is_empty

m.is_empty!
is_empty: { Bool }

空なら true。

>>> map.insertion.of([]).is_empty!
true

keys

m.keys!
keys: { List(Any) }

キーを挿入順の List で返す。

>>> map.insertion.of([("b", 2), ("a", 1)]).keys!
["b", "a"]

last

m.last!
last: { Option(Any) }

末尾 (最後に挿入された) エントリを Some((k, v))、空なら None。

>>> map.insertion.of([("b", 2), ("a", 1)]).last!
Some(("a", 1))

length

m.length!
length: { Int }

エントリ数。

>>> map.insertion.of([("a", 1), ("b", 2)]).length!
2

map

m.map { k, v | v' }
map: { Any | InsertionMap }

値を変換した新 InsertionMap (キー・順序不変)。

>>> map.insertion.of([("a", 1), ("b", 2)]).map { k, v | v * 10 }
InsertionMap{"a": 10, "b": 20}

merge

m.merge(other)
merge: { InsertionMap | InsertionMap }

マージした新 InsertionMap (同キーは右勝ち・位置維持、新規キーは末尾)。

>>> map.insertion.of([("a", 1)]).merge(map.insertion.of([("b", 2)]))
InsertionMap{"a": 1, "b": 2}

remove

m.remove(k)
remove: { Any | InsertionMap }

k を除いた新 InsertionMap (順序保存)。

>>> map.insertion.of([("a", 1), ("b", 2)]).remove("a")
InsertionMap{"b": 2}

to_list

m.to_list!
to_list: { List(Any) }

entries と同じ。

>>> map.insertion.of([("b", 2), ("a", 1)]).to_list!
[("b", 2), ("a", 1)]

values

m.values!
values: { List(Any) }

値を挿入順の List で返す。

>>> map.insertion.of([("b", 2), ("a", 1)]).values!
[2, 1]

SortedMap メソッド

compare

m.compare(other)
compare: { SortedMap | Ordering }

エントリ列の辞書式順序。

>>> map.sorted.of([("a", 1)]).compare(map.sorted.of([("b", 2)]))
Less

each

m.each { k, v | … }
each: { Any | Unit }

キー昇順に各エントリへ適用する。

>>> map.sorted.of([("a", 1), ("b", 2)]).each { k, v | println(k, v) }
("a", 1)
("b", 2)

entries

m.entries!
entries: { List(Any) }

(key, value) の昇順 List。

>>> map.sorted.of([("b", 2), ("a", 1)]).entries!
[("a", 1), ("b", 2)]

filter

m.filter { k, v | Bool }
filter: { Any | SortedMap }

述語が true のエントリだけの新 SortedMap。

>>> map.sorted.of([("a", 1), ("b", 2)]).filter { k, v | v > 1 }
SortedMap{"b": 2}

first

m.first!
first: { Option(Any) }

最小キーのエントリを Some((k, v))、空なら None。

>>> map.sorted.of([("a", 1), ("b", 2)]).first!
Some(("a", 1))

fold

m.fold(init) { acc, k, v | … }
fold: { Any, Any | Any }

キー昇順の左畳み込み。

>>> map.sorted.of([("a", 1), ("b", 2)]).fold(0) { acc, k, v | acc + v }
3

get

m.get(k)
get: { Any | Option(Any) }

キー k の値を Some(v)、無ければ None。

>>> map.sorted.of([("a", 1), ("b", 2)]).get("a")
Some(1)

has

m.has(k)
has: { Any | Bool }

キー k が存在すれば true。

>>> map.sorted.of([("a", 1)]).has("a")
true

insert

m.insert(k, v)
insert: { Any, Any | SortedMap }

k→v を加えた新 SortedMap (既存は上書き)。

>>> map.sorted.of([("a", 1), ("b", 2)]).insert("c", 3)
SortedMap{"a": 1, "b": 2, "c": 3}

is_empty

m.is_empty!
is_empty: { Bool }

空なら true。

>>> map.sorted.of([]).is_empty!
true

keys

m.keys!
keys: { List(Any) }

キーを compare 昇順の List で返す。

>>> map.sorted.of([("b", 2), ("a", 1)]).keys!
["a", "b"]

last

m.last!
last: { Option(Any) }

最大キーのエントリを Some((k, v))、空なら None。

>>> map.sorted.of([("a", 1), ("b", 2)]).last!
Some(("b", 2))

length

m.length!
length: { Int }

エントリ数。

>>> map.sorted.of([("a", 1), ("b", 2)]).length!
2

map

m.map { k, v | v' }
map: { Any | SortedMap }

値を変換した新 SortedMap (キーは不変)。

>>> map.sorted.of([("a", 1), ("b", 2)]).map { k, v | v * 10 }
SortedMap{"a": 10, "b": 20}

merge

m.merge(other)
merge: { SortedMap | SortedMap }

マージした新 SortedMap (同キーは右勝ち)。

>>> map.sorted.of([("a", 1)]).merge(map.sorted.of([("b", 2)]))
SortedMap{"a": 1, "b": 2}

remove

m.remove(k)
remove: { Any | SortedMap }

k を除いた新 SortedMap。

>>> map.sorted.of([("a", 1), ("b", 2)]).remove("a")
SortedMap{"b": 2}

to_list

m.to_list!
to_list: { List(Any) }

entries と同じ。

>>> map.sorted.of([("b", 2), ("a", 1)]).to_list!
[("a", 1), ("b", 2)]

values

m.values!
values: { List(Any) }

値をキー昇順に対応した List で返す。

>>> map.sorted.of([("b", 2), ("a", 1)]).values!
[1, 2]

insertion メソッド

empty

insertion.empty
empty: InsertionMap

空の InsertionMap (挿入順マップ)。

>>> map.insertion.empty
InsertionMap{}

of

insertion.of(pairs)
of: { Any | InsertionMap }

(key, value) の 2-Tuple の List から InsertionMap を構築する (キー重複は後勝ち・位置維持)。

>>> map.insertion.of([("b", 2), ("a", 1)])
InsertionMap{"b": 2, "a": 1}

sorted メソッド

empty

sorted.empty
empty: SortedMap

空の SortedMap (キー昇順マップ)。

>>> map.sorted.empty
SortedMap{}

of

sorted.of(pairs)
of: { Any | SortedMap }

(key, value) の 2-Tuple の List から SortedMap を構築する (キー重複は後勝ち)。

>>> map.sorted.of([("a", 1), ("b", 2)])
SortedMap{"a": 1, "b": 2}