Skip to content

Latest commit

 

History

History
397 lines (243 loc) · 17.1 KB

moyo_list.md

File metadata and controls

397 lines (243 loc) · 17.1 KB

Module moyo_list

リストに関する処理を集めたユーティリティモジュール.

Copyright (c) 2013-2014 DWANGO Co., Ltd. All Rights Reserved.

Function Index

adjacent_uniq/1List内で連接する重複要素を削除する.
delete_all/2List内に存在する全てのElementを削除する.
find_if/2PredFunの結果がtrueとなるList内の最初の要素を検索する.
foldl_while/3lists:foldl/3 の中断機能追加版: 関数適用後の結果が{false, _}となった場合は、そこで走査が中断される.
foldr_while/3lists:foldr/3 の中断機能追加版: 関数適用後の結果が{false, _}となった場合は、そこで走査が中断される.
group_by/2tuple の N 番目の値でグループ化する.
inits/1Listの全ての先頭部分リストを長さの増加する順に並べて返す.
longest_common_prefix/1Lists内のリスト群のLongestCommonPrefixの長さを返す.
maybe_filter/2lists:filter/2 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.
maybe_foldl/3lists:foldl/3 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.
maybe_foldr/3lists:foldr/3 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.
maybe_foreach/2lists:foreach/2 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.
maybe_map/2lists:map/2 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.
maybe_pmap/2Equivalent to maybe_pmap(Fun, List, infinity).
maybe_pmap/3maybe_map/2の並列版.
position/2List内で最初にValueが出現する位置を1-originで返す.
position_if/2List内で最初に述語PredFunを満たす要素の位置を1-originで返す.
replace_if/3PredFunの結果がtrueとなった最初の要素をValueで置換する.
shuffle/1入力リストの順番を無作為に並べ替える.
split_longest_common_prefix/1Lists内の各リストを'LongestCommonPrefix部分'と'それ以降のSuffix部分'に分割する.
tails/1Listの全ての末尾部分リストを長さの減少する順に並べて返す.
take/2Elementと一致する最初の要素を検索し、その値を除いたリストを返す.
take_if/2PredFunの結果がtrueとなるList内の最初の要素を検索し, その値とその値を除いたリストを返す.
uniq/1List内で重複要素を削除する.

Function Details

adjacent_uniq/1


adjacent_uniq(List::[term()]) -> [term()]

List内で連接する重複要素を削除する

リスト全体を通して各要素をユニークにしたい場合は、事前にリストをソートしておくか、 この関数の代わりにlists:usort/1またはmoyo_list:uniq/1を使う必要がある。

なお、要素の一致判定は=:=にて行われる (1.0と1は別要素扱い)

  > moyo_list:adjacent_uniq([a, a, b, b, c, c]).
  [a, b, c]
  > moyo_list:adjacent_uniq([a, a, b, b, a, a]).
  [a, b, a]

delete_all/2


delete_all(Element, List1) -> List2
  • Element = term()
  • List1 = [Element]
  • List2 = [Element]

List内に存在する全てのElementを削除する

  > moyo_list:delete_all(aaa, [aaa, bbb, ccc, bbb, aaa]).
  [bbb, ccc, bbb]

find_if/2


find_if(PredFun, List) -> {ok, Element} | error
  • PredFun = fun((Element) -> boolean())
  • List = [Element]
  • Element = term()

PredFunの結果がtrueとなるList内の最初の要素を検索する

foldl_while/3


foldl_while(Fun, Initial::term(), List) -> Result
  • Fun = fun((Element, Acc::term()) -> {true, Result} | {false, Result})
  • List = [Element]
  • Element = term()
  • Result = term()

lists:foldl/3 の中断機能追加版: 関数適用後の結果が{false, _}となった場合は、そこで走査が中断される.

Funの結果は{true, Result} or {false, Result}のいずれかである必要がある.

foldr_while/3


foldr_while(Fun, Initial::term(), List) -> Result
  • Fun = fun((Element, Acc::term()) -> {true, Result} | {false, Result})
  • List = [Element]
  • Element = term()
  • Result = term()

lists:foldr/3 の中断機能追加版: 関数適用後の結果が{false, _}となった場合は、そこで走査が中断される.

Funの結果は{true, Result} or {false, Result}のいずれかである必要がある.

group_by/2


group_by(N::non_neg_integer(), TupleList::[tuple()]) -> [{term(), [tuple()]}]

tuple の N 番目の値でグループ化する.

inits/1


inits(List::[Element]) -> [[Element]]
  • Element = term()

Listの全ての先頭部分リストを長さの増加する順に並べて返す

関数名およびインタフェースはHaskellのData.List.inits関数に倣った

  > moyo_list:inits("abc").
  ["", "a", "ab", "abc"]

longest_common_prefix/1


longest_common_prefix(Lists) -> LongestCommonPrefixLength
  • Lists = [List]
  • List = [term()]
  • LongestCommonPrefixLength = non_neg_integer()

Lists内のリスト群のLongestCommonPrefixの長さを返す

binary:longest_common_prefix/1のリスト版

  > moyo_list:longest_common_prefix(["erlang", "ergonomy"]).
  2
  > moyo_list:longest_common_prefix(["erlang", "perl"]).
  0

maybe_filter/2


maybe_filter(Fun, List) -> {ok, List} | {error, Reason}
  • Fun = fun((Element) -> boolean() | {error, Reason})
  • List = [Element]
  • Reason = term()

lists:filter/2 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.

Funの結果は boolean() or {error, Reason} のいずれかである必要がある.

maybe_foldl/3


maybe_foldl(Fun, Initial::term(), List) -> {ok, Result::term()} | {error, Reason}
  • Fun = fun((Element, Acc::term()) -> {ok, AccNext::term()} | {error, Reason})
  • List = [Element]
  • Element = term()
  • Reason = term()

lists:foldl/3 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.

Funの結果は {ok, Result} or {error, Reason} のいずれかである必要がある.

maybe_foldr/3


maybe_foldr(Fun, Initial::term(), List) -> {ok, Result::term()} | {error, Reason}
  • Fun = fun((Element, Acc::term()) -> {ok, AccNext::term()} | {error, Reason})
  • List = [Element]
  • Element = term()
  • Reason = term()

lists:foldr/3 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.

Funの結果は {ok, Result} or {error, Reason} のいずれかである必要がある.

maybe_foreach/2


maybe_foreach(Fun, List) -> ok | {error, Reason}
  • Fun = fun((Element) -> {error, Reason} | any())
  • List = [Element]
  • Element = term()
  • Reason = term()

lists:foreach/2 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.

Funの結果が{error, Reason}の場合はそこで走査が中断され、それ以外の場合は継続される.

maybe_map/2


maybe_map(Fun, List) -> {ok, Result} | {error, Reason}
  • Fun = fun((Element) -> {ok, PerResult} | {error, Reason})
  • List = [Element]
  • Element = term()
  • Result = [PerResult]
  • PerResult = term()
  • Reason = term()

lists:map/2 の maybe版: 関数適用結果が{error, Reason}となる要素があれば、そこで走査が中断される.

Funの結果は {ok, Result} or {error, Reason} のいずれかである必要がある.

maybe_pmap/2


maybe_pmap(Fun, List) -> {ok, Values} | {error, Reason}
  • Fun = fun((Arg) -> {ok, Value} | {error, Reason})
  • List = [Arg]
  • Values = [Value]
  • Arg = term()
  • Value = term()
  • Reason = ExitError | term()
  • ExitError = {EXIT, {ExitReason::term(), StackTrace::term()}}

Equivalent to maybe_pmap(Fun, List, infinity).

maybe_pmap/3


maybe_pmap(Fun, List, Timeout) -> {ok, Values} | {error, Reason}
  • Fun = fun((Arg) -> {ok, Value} | {error, Reason})
  • List = [Arg]
  • Timeout = timeout()
  • Values = [Value]
  • Arg = term()
  • Value = term()
  • Reason = ExitError | ExitTimeout | term()
  • ExitError = {EXIT, {ExitReason::term(), StackTrace::term()}}
  • ExitTimeout = {EXIT, timeout}

maybe_map/2の並列版.

Funの実行中のエラーが発生した場合はExitError、タイムアウトが発生した場合はExitTimeoutが結果として返される. また, 1つでも関数適用結果が{error, Reason}となる要素があれば, そこで走査を中断し、残ったプロセスを終了させる.

position/2


position(Value::term(), List::list()) -> {ok, Position::pos_integer()} | error

List内で最初にValueが出現する位置を1-originで返す

Valueが存在しない場合はerrorが返される

position_if/2


position_if(PredFun::fun((Element) -> boolean()), List::[Element]) -> {ok, pos_integer()} | error
  • Element = term()

List内で最初に述語PredFunを満たす要素の位置を1-originで返す

該当する要素が存在しない場合はerrorが返される

replace_if/3


replace_if(PredFun, Value::term(), List::list()) -> list()
  • PredFun = fun((term()) -> boolean())

PredFunの結果がtrueとなった最初の要素をValueで置換する

shuffle/1


shuffle(List::[Element]) -> [Element]
  • Element = term()

入力リストの順番を無作為に並べ替える

split_longest_common_prefix/1


split_longest_common_prefix(Lists) -> {LongestCommonPrefix, [Suffix]}
  • Lists = [List]
  • List = [term()]
  • LongestCommonPrefix = List
  • Suffix = List

Lists内の各リストを'LongestCommonPrefix部分'と'それ以降のSuffix部分'に分割する

なお'LongestCommonPrefix部分'は全てのリストで共通のため、結果では一つにまとめられている

  > moyo_list:split_longest_common_prefix(["erlang", "ergonomy"]).
  {"er", ["lang", "gonomy"]}
  > moyo_list:split_longest_common_prefix(["erlang", "perl"]).
  {"", ["erlang", "perl"]}

tails/1


tails(List::[Element]) -> [[Element]]
  • Element = term()

Listの全ての末尾部分リストを長さの減少する順に並べて返す

関数名およびインタフェースはHaskellのData.List.tails関数に倣った

  > moyo_list:tails("abc").
  ["abc", "ab", "a", ""]

take/2


take(Element, List1) -> {ok, List2} | error
  • Element = term()
  • List1 = [Element]
  • List2 = [Element]

Elementと一致する最初の要素を検索し、その値を除いたリストを返す

  > moyo_list:take(bbb, [aaa, bbb, ccc]).
  {ok, [aaa, ccc]}.
  > moyo_list:take(bbb, [111, 222, 333]).
  error

take_if/2


take_if(PredFun, List1) -> {ok, Element, List2} | error
  • PredFun = fun((Element) -> boolean())
  • List1 = [Element]
  • Element = term()
  • List2 = [Element]

PredFunの結果がtrueとなるList内の最初の要素を検索し, その値とその値を除いたリストを返す.

uniq/1


uniq(List::[term()]) -> [term()]

List内で重複要素を削除する

計算量はO(n log n). 要素の出現順は保存される. リストがソートされてもよい場合はlists:usort/1の方が高速. 連接する重複要素のみを削除したい場合はこの関数の代わりにmoyo_list:adjacent_uniq/1を使う.

なお, 要素の一致判定は=:=にて行われる (1.0と1は別要素扱い)

  > moyo_list:uniq([a, a, b, b, c, c]).
  [a, b, c]
  > moyo_list:uniq([c, a, c, b, b, a]).
  [c, a, b]