Erlang World

top > data type > lists

BIF Lists Module

BIFのlistsモジュールについて

前の節でBIF erlangモジュールのリストに関する関数を学びましたが、リスト処理専門のlistsというモジュールがBIFには存在します。

この節ではlistsモジュールの関数を中心として、リスト操作に関する操作を包括的に記載しています。
したがって、erlangモジュールの関数や、文法としてのリスト操作についても若干の記載があります。

全ての関数を記載しているわけではないので、詳細を知りたい方はマニュアルをご参照下さい。
マニュアル　listsモジュール

リストの反転

reverse(List1) -> List2

List1 = List2 = [term()]

リストの並びを逆転させる。

> lists:reverse([1,2,3,4,5,hello]).
[hello,5,4,3,2,1]
> lists:reverse("hello").
"olleh"

reverse(List1, Tail) -> List2

List1 = Tail = List2 = [term()]

List1を反転させ、Tailはそのままにし、両者を結合する。

> lists:reverse([1, 2, 3, 4], [a, b, c]).
[4,3,2,1,a,b,c]

リストの長さを得る

erlang:length(List) -> int()

List = [term()]

Listの長さを返す。

> length([1,2,3,4,5,6,7,8,9]).
9

特定の要素を得る

[Head | Tail] = List

Head = term()
Tail = List = [term()]

リストの先頭をHeadに格納し、それ以降をTailに格納する。

> [H | T] = [1,2,3,4].
[1,2,3,4]

> H.
1

> T.
[2,3,4]

erlang:hd(List) -> term()

List = [term()]

Listのヘッドを返す。

> erlang:hd([1,2,3,4]).
1

erlang:tl(List1) -> List2

List1 = List2 = [term()]

List1のテールを返す。

> erlang:tl([1,2,3,4]).  
[2,3,4]

last(List) -> Last

List = [term()], length(List) > 0
Last = term()

リストの末尾要素を得る。

last(List)
> lists:last([1,2,3,4]).
4

nth(N, List) -> Elem

N = 1..length(List)
List = [term()]
Elem = term()

リストのN番目の要素を得る。

nth(N, List)
> lists:nth(3,[a,b,c,d,e]).
c

max(List) -> Max

List = [term()], length(List) > 0
Max = term()

最大の値を得る。数字以外の値も比較するので注意。

> lists:max([1,5,3,8,2]).
8
> lists:max([3,hello,5,"good"]).
"good"

min(List) -> Min

List = [term()], length(List) > 0
Min = term()

最小の値を得る。数字以外も比較するので注意

> lists:min([3,5,2,9]).
2

条件判定

member(Elem, List) -> bool()

Elem = term()
List = [term()]

ElemがListの中に含まれている要素であればtrue、そうでなければfalseを返す。

> lists:member(5,[1,2,3,4,5,6]).
true
> lists:member(9,[1,2,3,4,5,6]).
false

all(Pred, List) -> bool()

Pred = fun(Elem) -> bool()
Elem = term()
List = [term()]

Listの要素全てにfun Preadを適用し、全てがtrueだったらtrueを返す。そうでないならfalseを返す。

> Is_int = fun(X) -> is_integer(X) end.
#Fun<erl_eval.6.13229925>
> lists:all(Is_int, [1,2,3,4,5,6]).
true
> lists:all(Is_int, [1,2,3,atom,5,6]).
false

any(Pred, List) -> bool()

Pred = fun(Elem) -> bool()
Elem = term()
List = [term()]

Listの要素全てにfun Preadを適用し、一つでもtrueだったらtrueを返す。全てfalseであればfalseを返す。

> lists:any(Is_int,[1,atom,3,erlang]).
true
> lists:any(Is_int,[hello,atom,good,erlang]).
false

prefix(List1, List2) -> bool()

List1 = List2 = [term()]

List1がList2の先頭にあればtrue、なければfalseを返す。

> lists:prefix([1,2,hello],[1,2,hello,good,erlang,6]).
true
24> lists:prefix([1,2,3],[1,2,hello,3,erlang,6]).       
false
> lists:prefix([1,2,hello],[0,1,2,hello,good,erlang,6]).
false

リストの結合

List1 = [Head | List2]

Head = term()
List1 = List2 = [term()]

List2の先頭にHeadを追加する。

> List = [0 | [1,2,3]].
[0,1,2,3]
> List1 = [0,1,2 | [3,4,5]].
[0,1,2,3,4,5]
> List2 = [[0,1] | [2,3,4]].
[[0,1],2,3,4]

List1 ++ List2

List1 = List2 = [term()]

List1とList2を結合する。

> [1,2,3,4] ++ [5,6,7,8].
[1,2,3,4,5,6,7,8]

append(ListOfLists) -> List1

ListOfLists = [List]
List = List1 = [term()]

Listから構成されているListを結合します。

> lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).
[1,2,3,a,b,4,5,6]

append(List1, List2) -> List3

List1 = List2 = List3 = [term()]

List1とList2を結合して、それを返す。

> lists:append([1,2,3,4],[5,6,7,8]).
[1,2,3,4,5,6,7,8]
> lists:append("abc", "def").
"abcdef"

リスト以外の要素のリストへの結合

concat(Things) -> string()

Things = [Thing]
Thing = atom() | integer() | float() | string()

リスト以外の要素をリストとして結合する

> lists:concat([doc, '/', file, '.', 3]).
"doc/file.3"

位置によるリストからの切り出し

delete(Elem, List1) -> List2

Elem = term()
List1 = List2 = [term()]

delete(Elem, List1)
List1から要素Elemを削除したリストを返す。
> lists:delete(3,[1,2,3,4,5]).
[1,2,4,5]
> lists:delete(8,[1,2,3,4,5]).
[1,2,3,4,5]

sublist(List1, Len) -> List2

List1 = List2 = [term()]
Len = int()

List1の１番目からLen番目までのリストを返す。もしLenがList1の要素数より多ければ、エラーとならずにList1の要素全てをリストとする。

> lists:sublist([1,2,3,4,5],3).
[1,2,3]
> lists:sublist([1,2,3,4,5],8).
[1,2,3,4,5]

sublist(List1, Start, Len) -> List2

List1 = List2 = [term()]
Start = 1..(length(List1)+1) Len = int()

List1のStart番目からLen番目までのリストを返す。もしLenがList1の要素数より多ければ、エラーとならずにList1の要素全てをリストとする。

> lists:sublist([1,2,3,4], 2, 2).
[2,3]
> lists:sublist([1,2,3,4], 2, 5).
[2,3,4]
> lists:sublist([1,2,3,4], 5, 2).
[]

nthtail(N, List1) -> Tail

N = 0..length(List1)
List1 = Tail = [term()]

リストのN番目以降の要素をリストとして返す。N番目は含まれない。

> lists:nthtail(3, [a, b, c, d, e]).
[d,e]
> lists:nthtail(0, [a, b, c, d, e]).
[a,b,c,d,e]
> lists:nthtail(5, [a, b, c, d, e]).
[]
> lists:nthtail(6, [a, b, c, d, e]).
** exception error: no function clause matching lists:nthtail(1,[])

条件によるリストからの切り出し

subtract(List1, List2) -> List3

List1 = List2 = List3 = [term()]

List2に含まれている要素をList1から取り除く。一要素につき取り除くのは一回のみです。

> lists:subtract("123212", "212").
"312".
1番目の1、2番目の2、4番目の2が取り除かれている。
6番目の2はすでのList2の2が使い果たされているので取り除かれない。

filter(Pred, List1) -> List2

Pred = fun(Elem) -> bool()
Elem = term()
List1 = List2 = [term()]

List1の要素からfun Pread がfalseとなるものを取り除く。

> Is_int = fun(X) -> is_integer(X) end.
#Fun<erl_eval.6.13229925>

> lists:filter(Is_int,[1,2,atom,erlang,5,6,hello,{hello}]).
[1,2,5,6]

filter(Pred, List1) -> List2

Pred = fun(Elem) -> bool()
Elem = term()
List1 = List2 = [term()]

List1にfun Pread を適用し、最初のfalseが出現するまでの集合を返す。

> lists:takewhile(Is_int, [1,2,3,4,atom,6,7]).
[1,2,3,4]

dropwhile(Pred, List1) -> List2

Pred = fun(Elem) -> bool()
Elem = term()
List1 = List2 = [term()]

List1からfun Preadがtrueになるものを削除する。一つでもfalseになるものがあったら、それ以後はチェックしない。

> lists:dropwhile(Is_int,[1,2,atom,erlang,5,{hello}]). 
[atom,erlang,5,{hello}]

dropwhile(Pred, List1)

リストの分割

split(N, List1) -> {List2, List3}

N = 0..length(List1)
List1 = List2 = List3 = [term()]

List1をN番目を境に２つに分ける。

> lists:split(4,[hello,2,5,1,5,3,erlang]). 
{[hello,2,5,1],[5,3,erlang]}

partition(Pred, List) -> {Satisfying, NonSatisfying}

Pred = fun(Elem) -> bool()
Elem = term()
List = Satisfying = NonSatisfying = [term()]

fun Preadがtrueの要素のグループとfalseの要素のグループに分離する。

> lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1,3,5,7],[2,4,6]}
> lists:partition(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b,c,d,e],[1,2,3,4]}

splitwith(Pred, List) -> {List1, List2}

Pred = fun(Elem) -> bool()
Elem = term()
List = List1 = List2 = [term()]

Listにfun Preadを適用し、最初に出て来たfalseより前のグループと、後ののグループに分ける。

> lists:splitwith(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1],[2,3,4,5,6,7]}
> lists:splitwith(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b],[1,c,d,2,3,4,e]}

リストのフラット化

flatten(DeepList) -> List

DeepList = [term() | DeepList]
List = [term()]

多重リストを平たくする。

> lists:flatten([1,2,[3,4,[5,6],7],8,9]).
[1,2,3,4,5,6,7,8,9]

flatlength(DeepList) -> int()

DeepList = [term() | DeepList]

リストの要素数を得る。多重リストの場合は内部のリストの中にある要素も数える。

> lists:flatlength([1,2,[3,4],5]).
5

flatmap(Fun, List1) -> List2

Fun = fun(A) -> [B]
List1 = [A]
List2 = [B]
A = B = term()

List1の各要素にFunを適用し、生成された値を連結する。もしFunにより生成される値がリストであれば、それらは結合される。

> lists:flatmap(fun(X)->[X,X] end, [a,b,c]).
[a,a,b,b,c,c]

リストに fun を適用

map(Fun, List1) -> List2

Fun = fun(A) -> B
List1 = [A]
List2 = [B]
A = B = term()

List1にFunを適用したリストを得ます。

> Double = fun(X) -> X*2 end.
#Fun<erl_eval.6.13229925>
> lists:map(Double,[1,2,3,4]).
[2,4,6,8]

> Double = fun(X) when is_integer(X) =:= true -> X * 2;
> (X) -> X end.                                        
#Fun<erl_eval.6.13229925>
> lists:map(Double,[1,2,hello,4,"good"]).
[2,4,hello,8,"good"]

foreach(Fun, List) -> void()

Fun = fun(Elem) -> void()
Elem = term()
List = [term()]

ListにFunを適用します。返り値はなく(okが返り値)、あくまでも副作用的な使い方しかありません。

> lists:foreach(fun(X) -> io:format("~p,",[X]) end, [1,2,3,4,5,hello,6]).
1,2,3,4,5,hello,6,ok

foldl(Fun, Acc0, List) -> Acc1

Fun = fun(Elem, AccIn) -> AccOut
Elem = term()
Acc0 = Acc1 = AccIn = AccOut = term()
List = [term()]

リストにたいしてファンを適応していく。ただし、ファンを適応させた結果を次のリストの要素にたいするファンの引数として渡す。つまり、AccIn == Acc0であり、AccOutは次の要素のAccInとなる。

> lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]).
15
> lists:foldl(fun(X, Prod) -> X * Prod end, 1, [1,2,3,4,5]).
120

リストの生成

duplicate(N, Elem) -> List

N = int()
Elem = term()
List = [term()]

要素がN個のリストを作り、その全ての要素をElemとする。

> lists:duplicate(5, xx).
[xx,xx,xx,xx,xx]

seq(From, To) -> Seq
seq(From, To, Incr) -> Seq

From = To = Incr = int()
Seq = [int()]

FromからToまでの整数のリストを作成する。Incrを指定した場合はその値ごとに要素の値が増えていく。デフォルトは1

> lists:seq(1, 10).
[1,2,3,4,5,6,7,8,9,10]

> lists:seq(1, 20, 3).
[1,4,7,10,13,16,19]

> lists:seq(10,0,-1).
[10,9,8,7,6,5,4,3,2,1,0]

ソート

sort(List1) -> List2

List1 = List2 = [term()]

List1を昇順にソートする。

> lists:sort([3,5,2,9,1,10,4,hello]).
[1,2,3,4,5,9,10,hello]

mail to :