-spec all(Pred, Q :: queue(Item)) -> boolean() when Pred :: fun((Item) -> boolean()).

如果 Pred(Item) 对 Q 中的所有项 Item 返回 true，则返回 true，否则返回 false。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
2> queue:all(fun (E) -> E > 3 end, Queue).
false
3> queue:all(fun (E) -> E > 0 end, Queue).
true

-spec any(Pred, Q :: queue(Item)) -> boolean() when Pred :: fun((Item) -> boolean()).

如果 Pred(Item) 对 Q 中至少一个项 Item 返回 true，则返回 true，否则返回 false。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
2> queue:any(fun (E) -> E > 10 end, Queue).
false
3> queue:any(fun (E) -> E > 3 end, Queue).
true

-spec delete(Item, Q1) -> Q2 when Item :: T, Q1 :: queue(T), Q2 :: queue(T), T :: term().

返回 Q1 的副本，其中删除了第一个匹配 Item 的项（如果有）。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
2> Queue1 = queue:delete(3, Queue).
3> queue:member(3, Queue1).
false

-spec delete_r(Item, Q1) -> Q2 when Item :: T, Q1 :: queue(T), Q2 :: queue(T), T :: term().

返回 Q1 的副本，其中删除了最后一个匹配 Item 的项（如果有）。

示例

1> Queue = queue:from_list([1,2,3,4,3,5]).
2> Queue1 = queue:delete_r(3, Queue).
3> queue:to_list(Queue1).
[1,2,3,4,5]

-spec delete_with(Pred, Q1) -> Q2
                     when
                         Pred :: fun((Item) -> boolean()),
                         Q1 :: queue(Item),
                         Q2 :: queue(Item),
                         Item :: term().

返回 Q1 的副本，其中删除了第一个 Pred 返回 true 的项（如果有）。

示例

1> Queue = queue:from_list([100,1,2,3,4,5]).
2> Queue1 = queue:delete_with(fun (E) -> E > 0, Queue).
3> queue:to_list(Queue1).
[1,2,3,4,5]

-spec delete_with_r(Pred, Q1) -> Q2
                       when
                           Pred :: fun((Item) -> boolean()),
                           Q1 :: queue(Item),
                           Q2 :: queue(Item),
                           Item :: term().

返回 Q1 的副本，其中删除了最后一个 Pred 返回 true 的项（如果有）。

示例

1> Queue = queue:from_list([1,2,3,4,5,100]).
2> Queue1 = queue:delete_with(fun (E) -> E > 10, Queue).
3> queue:to_list(Queue1).
[1,2,3,4,5]

-spec filter(Fun, Q1 :: queue(Item)) -> Q2 :: queue(Item) when Fun :: fun((Item) -> boolean() | [Item]).

返回一个队列 Q2，它是对 Q1 中的所有项调用 Fun(Item) 的结果。

如果 Fun(Item) 返回 true，则 Item 被复制到结果队列。如果它返回 false，则不复制 Item。如果它返回一个列表，则列表元素将插入结果队列，而不是 Item。

示例 1

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> Queue1 = queue:filter(fun (E) -> E > 2 end, Queue).
{[5],[3,4]}
3> queue:to_list(Queue1).
[3,4,5]

因此，Fun(Item) 返回 [Item] 在语义上等同于返回 true，正如返回 [] 在语义上等同于返回 false 一样。但返回一个列表比返回一个原子会产生更多的垃圾。

示例 2

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> Queue1 = queue:filter(fun (E) -> [E, E+1] end, Queue).
{[6,5,5,4,4,3],[1,2,2,3]}
3> queue:to_list(Queue1).
[1,2,2,3,3,4,4,5,5,6]

-spec filtermap(Fun, Q1) -> Q2
                   when
                       Fun :: fun((Item) -> boolean() | {true, Value}),
                       Q1 :: queue(Item),
                       Q2 :: queue(Item | Value),
                       Item :: term(),
                       Value :: term().

返回一个队列 Q2，它是对 Q1 中的所有项调用 Fun(Item) 的结果。

如果 Fun(Item) 返回 true，则 Item 将被复制到结果队列中。如果它返回 false，则 Item 不会被复制。如果它返回 {true, NewItem}，则结果队列中此位置的队列元素将被替换为 NewItem。

示例 1

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> Queue1 = queue:filtermap(fun (E) -> E > 2 end, Queue).
{[5],[3,4]}
3> queue:to_list(Queue1).
[3,4,5]
4> Queue1 = queue:filtermap(fun (E) -> {true, E+100} end, Queue).
{"ihg","ef"}
5> queue:to_list(Queue1).
"efghi

-spec fold(Fun, Acc0, Q :: queue(Item)) -> Acc1
              when
                  Fun :: fun((Item, AccIn) -> AccOut),
                  Acc0 :: term(),
                  Acc1 :: term(),
                  AccIn :: term(),
                  AccOut :: term().

在 Queue 的连续项 Item 上调用 Fun(Item, AccIn)，从 AccIn == Acc0 开始。队列按队列顺序遍历，即从前到后。Fun/2 必须返回一个新的累加器，该累加器将传递给下一次调用。该函数返回累加器的最终值。如果队列为空，则返回 Acc0。

示例

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

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

返回一个包含 L 中各项的队列，顺序相同；列表的头部项成为队列的前端项。

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

将 Item 插入队列 Q1 的尾部。返回结果队列 Q2。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> Queue1 = queue:in(100, Queue).
{[100,5,4,3],[1,2]}
3> queue:to_list(Queue1).
[1,2,3,4,5,100]

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

将 Item 插入队列 Q1 的前端。返回结果队列 Q2。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> Queue1 = queue:in_r(100, Queue).
{[5,4,3],[100,1,2]}
3> queue:to_list(Queue1).
[100,1,2,3,4,5]

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

测试 Q 是否为空，如果为空则返回 true，否则返回 false。

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

测试 Term 是否为队列，如果是则返回 true，否则返回 false。请注意，即使不是由此模块构造的，对于与队列的表示形式一致的项，此测试也会返回 true。另请参阅有关数据类型的说明。

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

返回一个队列 Q3，它是将 Q1 和 Q2 连接的结果，其中 Q1 在 Q2 的前面。

示例

1> Queue1 = queue:from_list([1,3]).
{[3],[1]}
2> Queue2 = queue:from_list([2,4]).
{[4],[2]}
3> queue:to_list(queue:join(Queue1, Queue2)).
[1,3,2,4]

-spec len(Q :: queue()) -> non_neg_integer().

计算并返回队列 Q 的长度。

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

如果 Item 与 Q 中的某个元素匹配，则返回 true，否则返回 false。

-spec new() -> queue(none()).

返回一个空队列。

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

删除队列 Q1 前端的项。返回元组 {{value, Item}, Q2}，其中 Item 是删除的项，Q2 是结果队列。如果 Q1 为空，则返回元组 {empty, Q1}。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> {{value, 1=Item}, Queue1} = queue:out(Queue).
{{value,1},{[5,4,3],[2]}}
3> queue:to_list(Queue1).
[2,3,4,5]

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

删除队列 Q1 后端的项。返回元组 {{value, Item}, Q2}，其中 Item 是删除的项，Q2 是新队列。如果 Q1 为空，则返回元组 {empty, Q1}。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> {{value, 5=Item}, Queue1} = queue:out_r(Queue).
{{value,5},{[4,3],[1,2]}}
3> queue:to_list(Queue1).
[1,2,3,4]

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

返回一个队列 Q2，其中包含 Q1 的项，顺序相反。

-spec split(N :: non_neg_integer(), Q1 :: queue(Item)) -> {Q2 :: queue(Item), Q3 :: queue(Item)}.

将 Q1 分成两部分。前面的 N 项放入 Q2，其余放入 Q3。

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

返回队列中各项的列表，顺序相同；队列的前端项成为列表的头部。

示例

1> Queue = queue:from_list([1,2,3,4,5]).
{[5,4,3],[1,2]}
2> List == queue:to_list(Queue).
true