std:map リファレンス

import map := "std:map" で取得する順序付きマップモジュール。キー昇順の SortedMap・挿入順の InsertionMap と、可変 scratch ハンドルの ScratchMap を提供する。

ScratchMap

AtMostOnce(ScratchMap(k, v))

map を組み立てる作業用ハンドル。AtMostOnce の多重度型で、frozen が Consuming
メソッドである。確定すると挿入順の不変 InsertionMap になる。set / remove / update は
連鎖のために受け手そのものを返すので、戻り型は Borrowed(ScratchMap(k, v)) である。

>>> import map := "std:map"
>>> handler := { m: map.ScratchMap | m }

insertion

insertion
insertion: { empty: InsertionMap(Never, Never), of: { List((k, v)) | InsertionMap(k, v) }, scratch: {| ScratchMap(k, v) }, build: { { Borrowed(ScratchMap(k, v)) | Any } | InsertionMap(k, v) } |}

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

>>> map.insertion.empty
InsertionMap{}

sorted

sorted
sorted: { empty: SortedMap(Never, Never), of: { List(((k: Comparable), v)) | SortedMap(k, v) } |}

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

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

InsertionMap メソッド

each

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

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

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

entries

m.entries!
entries: { List((k, v)) }

(key, value) の挿入順 List。

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

filter

m.filter { k, v | Bool }
filter: { EffectConduit({ k, v | Bool }) | InsertionMap(k, v) }

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

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

first

m.first!
first: { Option((k, v)) }

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

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

fold

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

挿入順の左畳み込み。

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

get

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

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

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

has

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

キー k が存在すれば true。

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

insert

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

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(k) }

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

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

last

m.last!
last: { Option((k, v)) }

末尾 (最後に挿入された) エントリを 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: { EffectConduit({ k, v | w }) | InsertionMap(k, w) }

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

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

merge

m.merge(other)
merge: { InsertionMap(k, v) | InsertionMap(k, v) }

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

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

remove

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

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

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

to_list

m.to_list!
to_list: { List((k, v)) }

entries と同じ。

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

values

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

値を挿入順の List で返す。

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

ScratchMap メソッド

frozen

h.frozen()
frozen: Consuming({ InsertionMap(k, v) })

内部状態を InsertionMap に確定し、ハンドルを封印する (以降の呼び出しは Error)。

>>> h := map.insertion.scratch()
>>> h.set("b", 2)
>>> h.set("a", 1)
>>> h.frozen()
InsertionMap{"b": 2, "a": 1}

get

h.get(k)
get: { k | Option(v) }

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

>>> h := map.insertion.scratch()
>>> h.set("a", 1)
>>> h.get("a")
Some(1)

has

h.has(k)
has: { k | Bool }

キー k が存在すれば true。

>>> h := map.insertion.scratch()
>>> h.set("a", 1)
>>> h.has("a")
true

keys

h.keys!
keys: { List(k) }

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

>>> h := map.insertion.scratch()
>>> h.set("b", 2)
>>> h.set("a", 1)
>>> h.keys!
["b", "a"]

length

h.length!
length: { Int }

エントリ数。

>>> h := map.insertion.scratch()
>>> h.set("a", 1)
>>> h.length!
1

remove

h.remove(k)
remove: { k | Effect(Borrowed(ScratchMap(k, v)), Mut) }

k を削除して self を返す (連鎖可)。無ければ何もしない。

効果ハンドラーの操作である。handle の操作スロットに remove と書いて横取りできる（language-spec.md §17.9）。

>>> h := map.insertion.scratch()
>>> h.set("a", 1)
>>> h.remove("a")
ScratchMap(0)

set

h.set(k, v)
set: { k, v | Effect(Borrowed(ScratchMap(k, v)), Mut) }

k→v を上書きまたは新規追加し self を返す (連鎖可)。既存キーは位置維持、新規キーは末尾。

効果ハンドラーの操作である。handle の操作スロットに set と書いて横取りできる（language-spec.md §17.9）。

>>> h := map.insertion.scratch()
>>> h.set("a", 1)
ScratchMap(1)

update

h.update(k, init) { v | v' }
update: { k, v, EffectConduit({ v | v }) | Effect(Borrowed(ScratchMap(k, v)), Mut) }

read-modify-write。k が存在すれば現在値を、無ければ init を block に渡し、
その戻り値を新しい値として書き込む。self を返す (連鎖可)。

効果ハンドラーの操作である。handle の操作スロットに update と書いて横取りできる（language-spec.md §17.9）。

>>> h := map.insertion.scratch()
>>> h.set("a", 1)
>>> h.update("a", 0) { v | v + 10 }
>>> h.update("z", 100) { v | v + 1 }
>>> [h.get("a"), h.get("z")]
[Some(11), Some(101)]

SortedMap メソッド

compare

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

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

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

each

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

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

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

entries

m.entries!
entries: { List((k, v)) }

(key, value) の昇順 List。

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

filter

m.filter { k, v | Bool }
filter: { EffectConduit({ k, v | Bool }) | SortedMap(k, v) }

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

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

first

m.first!
first: { Option((k, v)) }

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

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

fold

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

キー昇順の左畳み込み。

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

get

m.get(k)
get: { (k: Comparable) | Option(v) }

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

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

has

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

キー k が存在すれば true。

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

insert

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

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(k) }

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

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

last

m.last!
last: { Option((k, v)) }

最大キーのエントリを 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: { EffectConduit({ k, v | w }) | SortedMap(k, w) }

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

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

merge

m.merge(other)
merge: { SortedMap(k, v) | SortedMap(k, v) }

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

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

remove

m.remove(k)
remove: { (k: Comparable) | SortedMap(k, v) }

k を除いた新 SortedMap。

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

to_list

m.to_list!
to_list: { List((k, v)) }

entries と同じ。

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

values

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

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

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

insertion メソッド

build

insertion.build { h | … }
build: { EffectConduit({ Borrowed(ScratchMap(k, v)) | Any }) | InsertionMap(k, v) }

ScratchMap ハンドルを作りブロックを実行、終了時に frozen() した InsertionMap を
返す (scoped 糖衣。ハンドルが外へ漏れず、凍結し忘れがない)。

>>> h := map.insertion.build { h | h.set("x", 1) }
>>> h.keys!
["x"]

empty

insertion.empty
empty: InsertionMap(Never, Never)

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

>>> map.insertion.empty
InsertionMap{}

of

insertion.of(pairs)
of: { List((k, v)) | InsertionMap(k, v) }

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

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

scratch

insertion.scratch()
scratch: { ScratchMap }

空の ScratchMap (可変 scratch マップハンドル) を作る。呼ぶたびに独立した新しい
ハンドルを返す。

>>> map.insertion.scratch().length!
0

sorted メソッド

empty

sorted.empty
empty: SortedMap(Never, Never)

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

>>> map.sorted.empty
SortedMap{}

of

sorted.of(pairs)
of: { List(((k: Comparable), v)) | SortedMap(k, v) }

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

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