Erlang の queue モジュールを一通り試す - オリジナルAPI

new/0 関数

new() -> queue()

空のキューを返す。

> queue:new().
{[],[]}

in/2 関数

in(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)

キューQ1の後ろにアイテムを挿入した結果のキューQ2を返す。

> Q = queue:new().
{[],[]}
> queue:in(a, Q).
{[a],[]}
> Q1 = queue:in(a, Q). 
{[a],[]}
> Q2 = queue:in(b, Q1).
{[b],[a]}
> Q3 = queue:in(c, Q2).
{[c,b],[a]}
> Q4 = queue:in(d, Q3).
{[d,c,b],[a]}

out/1 関数

out(Q1 :: queue(Item)) -> {{value, Item}, Q2 :: queue(Item)} | {empty, Q1 :: queue(Item)}

キューQ1の前にあるアイテムを削除する。 タプル{{value, Item}, Q2}を返す。ここで、Itemは削除されたアイテムで、Q2はItemを削除した結果のキューである。Q1が空の場合、タプル{empty, Q1} が返される。

in/2 の続き
> {V5, Q5} = queue:out(Q4).
{{value,a},{[d,c],[b]}}
> {V6, Q6} = queue:out(Q5).
{{value,b},{[d],[c]}}
> {V7, Q7} = queue:out(Q6).
{{value,c},{[],[d]}}
> {V8, Q8} = queue:out(Q7). 
{{value,d},{[],[]}}
> queue:out(Q8).           
{empty,{[],[]}}

in_r/2 関数

in_r(Item, Q1 :: queue(Item)) -> Q2 :: queue(Item)

キューQ1の前にアイテムを挿入した結果のキューQ2を返す。

> Q = queue:new().
{[],[]}
> Q1 = queue:in_r(a, Q).
{[],[a]}
> Q2 = queue:in_r(b, Q1).
{[a],[b]}
> Q3 = queue:in_r(c, Q2).
{[a],[c,b]}
> Q4 = queue:in_r(d, Q3).
{[a],[d,c,b]}

out_r/1 関数

out_r(Q1 :: queue(Item)) -> {{value, Item}, Q2 :: queue(Item)} | {empty, Q1 :: queue(Item)}

キューQ1の後ろにあるアイテムを削除する。 タプル{{value, Item}, Q2}を返す。ここで、Itemは削除されたアイテムで、Q2はItemを削除した結果のキューである。Q1が空の場合、タプル{empty, Q1} が返される。

in_r/2 の続き
> {V5, Q5} = queue:out_r(Q4).
{{value,a},{[b],[d,c]}}
> {V6, Q6} = queue:out_r(Q5).
{{value,b},{[c],[d]}}
> {V7, Q7} = queue:out_r(Q6).
{{value,c},{[d],[]}}
> {V8, Q8} = queue:out_r(Q7).
{{value,d},{[],[]}}
> queue:out_r(Q8).
{empty,{[],[]}}

filter/1 関数

filter(Fun, Q1 :: queue(Item)) -> Q2 :: queue(Item)

Types

Fun = fun((Item) -> boolean() | [Item])

Q1のすべてのアイテムに対して、キューの前から後ろに順番に Fun(Item) を呼び出した結果であるキューQ2を返す。

Fun(Item) が true を返した場合、Itemは結果のキューにコピーされる。Fun(item)が false を返した場合、Item はコピーされない。Fun(Item) がリストを返す場合、リストの要素はItemの代わりに結果のキューに挿入される。

[Item]を返すFun(Item) は、trueを返すことと意味的に同等で、[]を返すことはfalseを返すことと意味的に同等である。ただし、リストを返すとアトムを返すよりも多くのガーベッジが構築される。

> Fun = fun(X) -> is_atom(X) end.
#Fun<erl_eval.7.126501267>
> L = ["a", "b", "c", x, y, z].      
["a","b","c",x,y,z]
> Q = queue:from_list(L). 
{[z,y],["a","b","c",x]}
> Q2 = queue:filter(Fun, Q).
{[z,y],[x]}
> queue:out(Q2).
{{value,x},{[z],[y]}}

from_list/1 関数

from_list(L :: [Item]) -> queue(Item)

同じ順序でLのアイテムを含むキューを返す。 リストの先頭項目がキューの先頭項目になる。

> L = [a,b,c].           
[a,b,c]
> Q = queue:from_list(L).
{[c],[a,b]}
> queue:out(Q).          
{{value,a},{[c],[b]}}

is_empty/1 関数

is_empty(Q :: queue()) -> boolean()

Qが空かどうかをテストし、空の場合はtrueを返し、そうでない場合はfalseを返す。

> Q = queue:new().
{[],[]}
> queue:is_empty(Q).
true
> Q1 = queue:in(a, Q).
{[a],[]}
> queue:is_empty(Q1).
false
> {V2, Q2} = queue:out(Q1).
{{value,a},{[],[]}}
> queue:is_empty(Q2).
true

is_queue/1 関数

is_queue(Term :: term()) -> boolean()

Termがキューかどうかをテストし、そうであればtrueを返し、そうでなければfalseを返す。

> Q = queue:new().
{[],[]}
> queue:is_queue(Q).
true
> L = [].           
[]
> queue:is_queue(L).
false
> T = {}.         
{}
> queue:is_queue(T).
false
> Q2 = {[],[]}.
{[],[]}
> queue:is_queue(Q2).
true
> queue:is_queue(Q3). 
true

len/1関数

len(Q :: queue()) -> integer() >= 0

queue の長さを返す。

> L = [a,b,c,d,e].
[a,b,c,d,e]
> Q = queue:from_list(L).
{[e,d],[a,b,c]}
> queue:len(Q).
5

member/2 関数

member(Item, Q :: queue(Item)) -> boolean()

ItemがQの要素に一致する場合はtrueを返し、そうでない場合はfalseを返す。

> L = [a,b,c,d,e].
[a,b,c,d,e]
> Q = queue:from_list(L).
{[e,d],[a,b,c]}
> queue:member(a, Q).
true
> queue:member(f, Q).
false

join/2 関数

join(Q1 :: queue(Item), Q2 :: queue(Item)) -> Q3 :: queue(Item)

Q2の前にQ1を結合した結果であるキューQ3を返す。

> L1 = [a,b,c].
[a,b,c]
> L2 = [1,2,3].
[1,2,3]
> Q1 = queue:from_list(L1).
{[c],[a,b]}
> Q2 = queue:from_list(L2).
{[3],[1,2]}
> queue:join(Q1, Q2).
{[3],[a,b,c,1,2]}
> Q3 = queue:join(Q1, Q2).
{[3],[a,b,c,1,2]}
> queue:out(Q3).
{{value,a},{[3],[b,c,1,2]}}

reverse/1 関数

reverse(Q1 :: queue(Item)) -> Q2 :: queue(Item)

Q1のアイテムを逆の順序にしたキューQ2を返す。

> L = [1,2,3,4,5].
[1,2,3,4,5]
> Q = queue:from_list(L).
{[5,4],[1,2,3]}
> queue:out(Q).
{{value,1},{[5,4],[2,3]}}
> Q_r = queue:reverse(Q).
{[1,2,3],[5,4]}
> queue:out(Q_r).
{{value,5},{[1,2,3],[4]}}

to_list/1 関数

to_list(Q :: queue(Item)) -> [Item]

キューのアイテムを同じ順序でリストにして返す。 キューの先頭のアイテムがリストの先頭になる。

> Q1 = queue:new().
{[],[]}
> Q2 = queue:in(a, Q1).
{[a],[]}
> Q3 = queue:in(b, Q2).
{[b],[a]}
> Q4 = queue:in(c, Q3). 
{[c,b],[a]}
> queue:to_list(Q4).
[a,b,c]

split/2 関数

split(N :: integer() >= 0, Q1 :: queue(Item)) -> {Q2 :: queue(Item), Q3 :: queue(Item)}

Q1を2つに分割する。N個のフロントアイテムはQ2に、残りはQ3に入れられる。

> L = [a,b,c,d,e].
[a,b,c,d,e]
> Q1 = queue:from_list(L).
{[e,d],[a,b,c]}
> {Q2, Q3} = queue:split(3, Q1).
{{[c],[a,b]},{[e],[d]}}
> Q2.
{[c],[a,b]}
> Q3.
{[e],[d]}
> queue:len(Q2).                
3
> queue:len(Q3).
2