Erlang の lists モジュールを一通り試す - その3

最近、Erlang のコードを読んでいて、lists:any という関数が出てきたのだが、知らなかったので調べた。ついでに、他の関数も一通り眺めておく。

公式URL: http://erlang.org/doc/man/lists.html

keydelete/3 関数

keydelete(Key, N, TupleList1) -> TupleList2

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
Tuple = tuple()

タプルの要素の N 番目が Key と一致するタプルが TupleList1 に存在する場合、その要素を削除した TupleList2 を返す。

> lists:keydelete(a, 1, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).
[{b,"B"},{c,"C"}]
> lists:keydelete("B", 2, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).  
[{a,"A1","A2"},{c,"C"}]
> lists:keydelete("A2", 3, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).
[{b,"B"},{c,"C"}]

1つ目の例は、タプルの1つ目の要素を対象に、a と一致するタプルがあれば、それを削除される。{a, "A1", "A2"}の1つ目の要素aが一致するため、このタプルが削除された。

2つ目の例は、タプルの2つ目の要素を対象に、"B"と一致するタプルがあれば、それを削除する。{b, "B"}の2つ目の要素が"B"に一致するため、このタプルが削除された。

3つ目の例は、タプル3つ目の要素を対象に、"A2"と一致するタプルがあれば、それを削除する。{a, "A1", "A2"}の3つ目の要素が"A2"なので、このタプルが削除された。

keyfind/3 関数

keyfind(Key, N, TupleList) -> Tuple | false

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList = [Tuple]
Tuple = tuple()

タプルの要素の N 番目が Key と一致するタプルが TupleList1 に存在する場合、その Tuple を返す。それ以外の場合は、falseを返す。

> lists:keyfind(a, 1, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).     
{a,"A1","A2"}
> lists:keyfind("B", 2, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).   
{b,"B"}
> lists:keyfind(d, 1, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).     
false

keymap/3 関数

keymap(Fun, N, TupleList1) -> TupleList2

Types

Fun = fun((Term1 :: term()) -> Term2 :: term())
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
Tuple = tuple()

TupleList1 の各タプルについて、タプルのN番目の要素 Term1 に Fun(Term1) を実行した結果に置き換えられたタプルのリストを返す。

> F = fun(Int) -> integer_to_list(Int) end.
#Fun<erl_eval.6.99386804>
> lists:keymap(F, 2, [{apple,120},{banana, 160},{strawberry, 140}]).
[{apple,"120"},{banana,"160"},{strawberry,"140"}]

上の例では、タプルの2番目の要素である整数が、関数 F で文字列に変更された結果に置き換えられている。

keymember/3 関数

keymember(Key, N, TupleList) -> boolean()

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList = [Tuple]
Tuple = tuple()

TupleList の N 番目の要素が Key と等しいタプルがある場合は true を返し、そうでない場合はfalseを返す。

> lists:keymember(apple, 1, [{apple,120},{banana, 160},{strawberry, 140}]).
true
> lists:keymember(pineapple, 1, [{apple,120},{banana, 160},{strawberry, 140}]).
false
> lists:keymember(160, 2, [{apple,120},{banana, 160},{strawberry, 140}]).      
true
> lists:keymember(apple, 2, [{apple,120},{banana, 160},{strawberry, 140}]).
false

keymerge/3 関数

keymerge(N, TupleList1, TupleList2) -> TupleList3

Types

N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = [T1]
TupleList2 = [T2]
TupleList3 = [T1 | T2]
T1 = T2 = Tuple
Tuple = tuple()

TupleList1 と TupleList2 をマージしたソート済みリストを返す。 マージは、各タプルの N 番目の要素で実行される。 この関数を評価する前に、TupleList1 と TupleList2 の両方をキーでソートする必要がある。2つのタプルが等しい場合、TupleList1 のタプルが TupleList2のタプルの前に選択される。

下記は、タプルの要素1つ目でソートしたタプルのリストを渡した例である。マージして得られた結果も要素1つ目でソートされている。

> TupleList1 = [{apple,130},{cherry,160}].
> TupleList2 = [{apple,120},{banana,130},{strawberry,140}].
> lists:keymerge(1, TupleList1, TupleList2).
[{apple,130},
 {apple,120},
 {banana,130},
 {cherry,160},
 {strawberry,140}]

下記は、第2引数に TupleList2 と第3引数に TupleList2 を与えた。得られた結果が上記のものと異なる。同じキーがある場合は、第2引数のものが先にくる。

> lists:keymerge(1, TupleList2, TupleList1).               
[{apple,120},
 {apple,130},
 {banana,130},
 {cherry,160},
 {strawberry,140}]

下記は、わざと TupleList1 をソートされていないタプルのリストにした。マージして得られた結果は要素1つ目でソートされていない。

> TupleList1 = [{cherry, 160},{apple,130}]. 
> TupleList2 = [{apple,120},{banana,130},{strawberry,140}].
> lists:keymerge(1, TupleList1, TupleList2).
[{apple,120},
 {banana,130},
 {cherry,160},
 {apple,130},
 {strawberry,140}]

keyreplace/4 関数

keyreplace(Key, N, TupleList1, NewTuple) -> TupleList2

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
NewTuple = Tuple
Tuple = tuple()

TupleList1に、N番目の要素がKeyと等しいタプルがある場合、一番最初のものだけが NewTuple に置き換えられる。

> TupleList1 = [{apple,130},{apple,140},{cherry,160}].
> NewTuple = {apple, 150}.
> lists:keyreplace(apple, 1, TupleList1, NewTuple).
[{apple,150},{apple,140},{cherry,160}]
> NewTuple2 = {banana, 170}.
> lists:keyreplace(banana, 1, TupleList1, NewTuple2).
[{apple,130},{apple,140},{cherry,160}]

上記は、要素1番目のものが apple であることを条件にタプルの置き換えをした。 {apple, 130} から {apple, 150} へタプルを置き換えた例だ。要素1番目に apple をもつタプルが2つあるが、最初のタプルだけが置き換えられている点に注意する。

また、Key と一致するタプルがなければ、TupleList1 を返す。

keysearch/3 関数

keysearch(Key, N, TupleList) -> {value, Tuple} | false

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList = [Tuple]
Tuple = tuple()

タプルのリスト TupleList で、N番目の要素がKeyと等しいタプルを検索する。そのようなタプルが見つかった場合は{value、Tuple}を返し、それ以外の場合はfalseを返す。

この関数は後方互換性のために残されたもので、通常は keyfind/3 関数の方を使う。

> lists:keysearch(a, 1, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).   
{value,{a,"A1","A2"}}
> lists:keysearch("B", 2, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]). 
{value,{b,"B"}}
> lists:keysearch(d, 1, [{a, "A1", "A2"}, {b, "B"}, {c, "C"}]).   
false

keysort/2 関数

keysort(N, TupleList1) -> TupleList2

Types

N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [Tuple]
Tuple = tuple()

TupleList1 をタプル N番目の要素でソートしたリストを返す。

> TupleList1 = [{banana,170},{strawberry,140}, {apple, 120}].
> lists:keysort(1, TupleList1).
[{apple,120},{banana,170},{strawberry,140}]
> lists:keysort(2, TupleList1).
[{apple,120},{strawberry,140},{banana,170}]

keystore/4 関数

keystore(Key, N, TupleList1, NewTuple) -> TupleList2

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = [Tuple]
TupleList2 = [Tuple, ...]
NewTuple = Tuple
Tuple = tuple()

TupleList1に、N番目の要素がKeyと等しいタプルがある場合、一番最初のものだけが NewTuple に置き換えられる。そのようなタプルが無い場合は、NewTuple が最後に追加されたリストを返す。

> TupleList1 = [{apple,130},{apple,140},{cherry,160}].
> NewTuple = {apple, 150}.
> lists:keystore(apple, 1, TupleList1, NewTuple).
[{apple,150},{apple,140},{cherry,160}]
> NewTuple2 = {banana, 170}.
> lists:keystore(banana, 1, TupleList1, NewTuple2). 
[{apple,130},{apple,140},{cherry,160},{banana,170}]

keyreplace/4 関数と似ているが、Keyと一致するタプルが見つからない場合はリストの最後に NewTuple を追加する点が異なる。 この関数も、Keyと一致するタプルが見つかった場合に、NewTupleに置き換わるのは最初の1つだけなので、注意する。

keytake/3 関数

keytake(Key, N, TupleList1) -> {value, Tuple, TupleList2} | false

Types

Key = term()
N = integer() >= 1
1..tuple_size(Tuple)
TupleList1 = TupleList2 = [tuple()]
Tuple = tuple()

タプルのリストTupleList1で、N番目の要素がKeyと等しいタプルを検索する。 そのようなタプルが見つかった場合は {value、Tuple、TupleList2} を返し、それ以外の場合はfalseを返す。 TupleList2は、TupleList1 から Tupleの最初の出現が削除されたもの。

> TupleList1 = [{apple,130},{apple,140},{cherry,160}].
[{apple,130},{apple,140},{cherry,160}]
> lists:keytake(apple, 1, TupleList1).                
{value,{apple,130},[{apple,140},{cherry,160}]}

上の例では、appleをキーにして最初に一致したタプル {apple, 130} を取得した。2つ目の {apple, 140} は取得されず TupleList2 に残っている点に注意する。

last/1 関数

last(List) -> Last

Types

List = [T, ...]
Last = T
T = term()

Listの最後の要素を返す。

> lists:last([a,b,c,d,e]).
e