From 48654b06afc07dba4342e02293b9adb9776d99d1 Mon Sep 17 00:00:00 2001 From: Kostis Sagonas Date: Mon, 8 Feb 2010 10:29:31 +0200 Subject: stdlib: clean up as suggested by tidier Hans Bolinder (the author/maintainer of qlc) prefers for readability reasons to use length/1 in a guard when it is known that the list is guaranteed to be short, so the change suggested by tidier for line 875 of qlc_pt has not been included. --- lib/stdlib/src/dets_v8.erl | 30 ++++----- lib/stdlib/src/edlin.erl | 10 ++- lib/stdlib/src/file_sorter.erl | 24 +++---- lib/stdlib/src/qlc.erl | 149 +++++++++++++++++++---------------------- lib/stdlib/src/qlc_pt.erl | 22 +++--- 5 files changed, 111 insertions(+), 124 deletions(-) (limited to 'lib/stdlib') diff --git a/lib/stdlib/src/dets_v8.erl b/lib/stdlib/src/dets_v8.erl index b24df02882..ec3bad45bc 100644 --- a/lib/stdlib/src/dets_v8.erl +++ b/lib/stdlib/src/dets_v8.erl @@ -1053,14 +1053,14 @@ wl([{_Seq, {insert, Object}} | Cs], Type, _Del, Lookup, _I, _Objs) wl(Cs, Type, delete, Lookup, 1, [{Object,-1}]); wl([{_Seq, {insert, Object}} | Cs], Type, Del, Lookup, _I, Objs) -> NObjs = - case lists:keysearch(Object, 1, Objs) of - {value, {_, 0}} -> + case lists:keyfind(Object, 1, Objs) of + {_, 0} -> lists:keyreplace(Object, 1, Objs, {Object,-1}); - {value, {_, _C}} when Type =:= bag -> % C =:= 1; C =:= -1 + {_, _C} when Type =:= bag -> % C =:= 1; C =:= -1 Objs; - {value, {_, C}} when C < 0 -> % when Type =:= duplicate_bag + {_, C} when C < 0 -> % when Type =:= duplicate_bag lists:keyreplace(Object, 1, Objs, {Object,C-1}); - {value, {_, C}} -> % when C > 0, Type =:= duplicate_bag + {_, C} -> % when C > 0, Type =:= duplicate_bag lists:keyreplace(Object, 1, Objs, {Object,C+1}); false when Del =:= delete -> [{Object, -1} | Objs]; @@ -1258,8 +1258,8 @@ eval_slot(Head, TrySize, Pos, WLs, L, LU) -> find_key(Head, Pos, NextPos, Size, Term, Key, WLs, L, LU). find_key(Head, Pos, NextPos, Size, Term, Key, WLs, L, LU) -> - case lists:keysearch(Key, 1, WLs) of - {value, {_, {Delete, LookUp, Objects}} = WL} -> + case lists:keyfind(Key, 1, WLs) of + {_, {Delete, LookUp, Objects}} = WL -> NWLs = lists:delete(WL, WLs), {NewObjects, NL, LUK} = eval_object(Size, Term, Delete, LookUp, Objects, Head, Pos, L, []), @@ -1297,30 +1297,30 @@ eval_key(Key, Delete, LookUp, Objects, Head, Pos, WLs, L, LU, LUK) -> %% All objects in Objects have the key Key. eval_object(Size, Term, Delete, LookUp, Objects, Head, Pos, L, LU) -> Type = Head#head.type, - case lists:keysearch(Term, 1, Objects) of - {value, {_Object, N}} when N =:= 0 -> + case lists:keyfind(Term, 1, Objects) of + {_Object, N} when N =:= 0 -> L1 = [{delete,Pos,Size} | L], {Objects, L1, LU}; - {value, {_Object, N}} when N < 0, Type =:= set -> + {_Object, N} when N < 0, Type =:= set -> L1 = [{old,Pos} | L], wl_lookup(LookUp, Objects, Term, L1, LU); - {value, {Object, _N}} when Type =:= bag -> % when N =:= 1; N =:= -1 + {Object, _N} when Type =:= bag -> % when N =:= 1; N =:= -1 L1 = [{old,Pos} | L], Objects1 = lists:keydelete(Object, 1, Objects), wl_lookup(LookUp, Objects1, Term, L1, LU); - {value, {Object, N}} when N < 0, Type =:= duplicate_bag -> + {Object, N} when N < 0, Type =:= duplicate_bag -> L1 = [{old,Pos} | L], Objects1 = lists:keyreplace(Object, 1, Objects, {Object,N+1}), wl_lookup(LookUp, Objects1, Term, L1, LU); - {value, {_Object, N}} when N > 0, Type =:= duplicate_bag -> + {_Object, N} when N > 0, Type =:= duplicate_bag -> L1 = [{old,Pos} | L], wl_lookup(LookUp, Objects, Term, L1, LU); false when Type =:= set, Delete =:= delete -> - case lists:keysearch(-1, 2, Objects) of + case lists:keyfind(-1, 2, Objects) of false -> % no inserted object, perhaps deleted objects L1 = [{delete,Pos,Size} | L], {[], L1, LU}; - {value, {Term2,-1}} -> + {Term2, -1} -> Bin2 = term_to_binary(Term2), NSize = byte_size(Bin2), Overwrite = diff --git a/lib/stdlib/src/edlin.erl b/lib/stdlib/src/edlin.erl index 0e98bbaa06..6cb441dbed 100644 --- a/lib/stdlib/src/edlin.erl +++ b/lib/stdlib/src/edlin.erl @@ -30,8 +30,6 @@ -import(lists, [reverse/1, reverse/2]). -%-import([nthtail/2, keysearch/3, prefix/2]). - -export([over_word/3]). @@ -476,8 +474,8 @@ prompt({line,Pbs,_,_}) -> %% case erlang:module_loaded(Mod) of %% true -> %% L = apply(Mod, module_info, []), -%% case keysearch(exports, 1, L) of -%% {value, {_, Exports}} -> +%% case lists:keyfind(exports, 1, L) of +%% {_, Exports} -> %% match(FuncPrefix, Exports, "("); %% _ -> %% no @@ -493,7 +491,7 @@ prompt({line,Pbs,_,_}) -> %% print_matches(Matches), %% no; %% {partial, Str} -> -%% case nthtail(length(Prefix), Str) of +%% case lists:nthtail(length(Prefix), Str) of %% [] -> %% print_matches(Matches), %% {yes, []}; @@ -501,7 +499,7 @@ prompt({line,Pbs,_,_}) -> %% {yes, Remain} %% end; %% {complete, Str} -> -%% {yes, nthtail(length(Prefix), Str) ++ Extra}; +%% {yes, lists:nthtail(length(Prefix), Str) ++ Extra}; %% no -> %% no %% end. diff --git a/lib/stdlib/src/file_sorter.erl b/lib/stdlib/src/file_sorter.erl index de9e628e22..f253791f80 100644 --- a/lib/stdlib/src/file_sorter.erl +++ b/lib/stdlib/src/file_sorter.erl @@ -186,7 +186,7 @@ options(Option) -> options([{format, Format} | L], Opts) when Format =:= binary; Format =:= term; is_function(Format), - is_function(Format, 1) -> + is_function(Format, 1) -> options(L, Opts#opts{format = Format}); options([{format, binary_term} | L], Opts) -> options(L, Opts#opts{format = binary_term_fun()}); @@ -419,9 +419,9 @@ culprit_found(IFun, F, FNs, W, L, I, [_Size | BT]) -> IFun(close), check_files(FNs, W, [{F,I,binary_to_term(BT)} | L]). -files(_I, L, _LSz, #w{seq = 1}=W, []) -> +files(_I, L, _LSz, #w{seq = 1, out = Out}=W, []) -> %% No temporary files created, everything in L. - case W#w.out of + case Out of Fun when is_function(Fun) -> SL = internal_sort(L, W), W1 = outfun(binterm_objects(SL, []), W), @@ -462,8 +462,8 @@ fun_run(I, L, LSz, W, []) -> {cont, NW, Objs} -> fun_run(I, L, LSz, NW, Objs) end; -fun_run(I, L, LSz, W, Objs) when LSz < W#w.runsize -> - {NI, NObjs, NL, NLSz} = fun_objs(Objs, L, LSz, W#w.runsize, I, W), +fun_run(I, L, LSz, #w{runsize = Runsize}=W, Objs) when LSz < Runsize -> + {NI, NObjs, NL, NLSz} = fun_objs(Objs, L, LSz, Runsize, I, W), fun_run(NI, NL, NLSz, W, NObjs); fun_run(I, L, _LSz, W, Objs) -> NW = write_run(L, W), @@ -1201,11 +1201,11 @@ infun(W) -> erlang:raise(Class, Reason, erlang:get_stacktrace()) end. -outfun(A, W) when W#w.inout_value =/= no_value -> +outfun(A, #w{inout_value = Val} = W) when Val =/= no_value -> W1 = W#w{inout_value = no_value}, W2 = if W1#w.fun_out -> - outfun(W#w.inout_value, W1); + outfun(Val, W1); true -> W1 end, outfun(A, W2); @@ -1372,19 +1372,19 @@ cleanup(W) -> end, lists:foreach(F, W1#w.temp). -close_input(W) when is_function(W#w.in) -> - catch (W#w.in)(close), +close_input(#w{in = In}=W) when is_function(In) -> + catch In(close), W#w{in = undefined}; close_input(#w{in = undefined}=W) -> W. -close_out(W) when is_function(W#w.out) -> - catch (W#w.out)(close); +close_out(#w{out = Out}) when is_function(Out) -> + catch Out(close); close_out(_) -> ok. close_file(Fd, W) -> - {value, {Fd, FileName}} = lists:keysearch(Fd, 1, W#w.temp), + {Fd, FileName} = lists:keyfind(Fd, 1, W#w.temp), ?DEBUG("closing ~p~n", [FileName]), file:close(Fd), W#w{temp = [FileName | lists:keydelete(Fd, 1, W#w.temp)]}. diff --git a/lib/stdlib/src/qlc.erl b/lib/stdlib/src/qlc.erl index ef142e1c8a..bbeeb503e5 100644 --- a/lib/stdlib/src/qlc.erl +++ b/lib/stdlib/src/qlc.erl @@ -528,122 +528,111 @@ options(Options0, [Key | Keys], L) when is_list(Options0) -> false -> Options0 end, - V = case lists:keysearch(Key, 1, Options) of - {value, {format_fun, U=undefined}} -> + V = case lists:keyfind(Key, 1, Options) of + {format_fun, U=undefined} -> {ok, U}; - {value, {info_fun, U=undefined}} -> + {info_fun, U=undefined} -> {ok, U}; - {value, {lookup_fun, U=undefined}} -> + {lookup_fun, U=undefined} -> {ok, U}; - {value, {parent_fun, U=undefined}} -> + {parent_fun, U=undefined} -> {ok, U}; - {value, {post_fun, U=undefined}} -> + {post_fun, U=undefined} -> {ok, U}; - {value, {pre_fun, U=undefined}} -> + {pre_fun, U=undefined} -> {ok, U}; - {value, {info_fun, Fun}} when is_function(Fun), - is_function(Fun, 1) -> + {info_fun, Fun} when is_function(Fun), is_function(Fun, 1) -> {ok, Fun}; - {value, {pre_fun, Fun}} when is_function(Fun), - is_function(Fun, 1) -> + {pre_fun, Fun} when is_function(Fun), is_function(Fun, 1) -> {ok, Fun}; - {value, {post_fun, Fun}} when is_function(Fun), - is_function(Fun, 0) -> + {post_fun, Fun} when is_function(Fun), is_function(Fun, 0) -> {ok, Fun}; - {value, {lookup_fun, Fun}} when is_function(Fun), - is_function(Fun, 2) -> + {lookup_fun, Fun} when is_function(Fun), is_function(Fun, 2) -> {ok, Fun}; - {value, {max_lookup, Max}} when is_integer(Max), Max >= 0 -> + {max_lookup, Max} when is_integer(Max), Max >= 0 -> {ok, Max}; - {value, {max_lookup, infinity}} -> + {max_lookup, infinity} -> {ok, -1}; - {value, {format_fun, Fun}} when is_function(Fun), - is_function(Fun, 1) -> + {format_fun, Fun} when is_function(Fun), is_function(Fun, 1) -> {ok, Fun}; - {value, {parent_fun, Fun}} when is_function(Fun), - is_function(Fun, 0) -> + {parent_fun, Fun} when is_function(Fun), is_function(Fun, 0) -> {ok, Fun}; - {value, {key_equality, KE='=='}}-> + {key_equality, KE='=='} -> {ok, KE}; - {value, {key_equality, KE='=:='}}-> + {key_equality, KE='=:='} -> {ok, KE}; - {value, {join, J=any}} -> + {join, J=any} -> {ok, J}; - {value, {join, J=nested_loop}} -> + {join, J=nested_loop} -> {ok, J}; - {value, {join, J=merge}} -> + {join, J=merge} -> {ok, J}; - {value, {join, J=lookup}} -> + {join, J=lookup} -> {ok, J}; - {value, {lookup, LookUp}} when LookUp; - not LookUp; - LookUp =:= any -> + {lookup, LookUp} when is_boolean(LookUp); LookUp =:= any -> {ok, LookUp}; - {value, {max_list_size, Max}} when is_integer(Max), Max >= 0 -> + {max_list_size, Max} when is_integer(Max), Max >= 0 -> {ok, Max}; - {value, {tmpdir_usage, TmpUsage}} when TmpUsage =:= allowed; - TmpUsage =:= not_allowed; - TmpUsage =:= info_msg; - TmpUsage =:= warning_msg; - TmpUsage =:= error_msg -> + {tmpdir_usage, TmpUsage} when TmpUsage =:= allowed; + TmpUsage =:= not_allowed; + TmpUsage =:= info_msg; + TmpUsage =:= warning_msg; + TmpUsage =:= error_msg -> {ok, TmpUsage}; - {value, {unique, Unique}} when Unique; not Unique -> + {unique, Unique} when is_boolean(Unique) -> {ok, Unique}; - {value, {cache, Cache}} when Cache; not Cache; Cache =:= list -> + {cache, Cache} when is_boolean(Cache); Cache =:= list -> {ok, Cache}; - {value, {cache, ets}} -> + {cache, ets} -> {ok, true}; - {value, {cache, no}} -> + {cache, no} -> {ok, false}; - {value, {unique_all, UniqueAll}} when UniqueAll; not UniqueAll -> + {unique_all, UniqueAll} when is_boolean(UniqueAll) -> {ok, UniqueAll}; - {value, {cache_all, CacheAll}} when CacheAll; - not CacheAll; - CacheAll =:= list -> + {cache_all, CacheAll} when is_boolean(CacheAll); + CacheAll =:= list -> {ok, CacheAll}; - {value, {cache_all, ets}} -> + {cache_all, ets} -> {ok, true}; - {value, {cache_all, no}} -> + {cache_all, no} -> {ok, false}; - {value, {spawn_options, default}} -> + {spawn_options, default} -> {ok, default}; - {value, {spawn_options, SpawnOptions}} -> + {spawn_options, SpawnOptions} -> case is_proper_list(SpawnOptions) of true -> {ok, SpawnOptions}; false -> badarg end; - {value, {flat, Flat}} when Flat; not Flat -> + {flat, Flat} when is_boolean(Flat) -> {ok, Flat}; - {value, {format, Format}} when Format =:= string; - Format =:= abstract_code; - Format =:= debug -> + {format, Format} when Format =:= string; + Format =:= abstract_code; + Format =:= debug -> {ok, Format}; - {value, {n_elements, NElements}} when NElements =:= infinity; - is_integer(NElements), - NElements > 0 -> + {n_elements, NElements} when NElements =:= infinity; + is_integer(NElements), + NElements > 0 -> {ok, NElements}; - {value, {depth, Depth}} when Depth =:= infinity; - is_integer(Depth), Depth >= 0 -> + {depth, Depth} when Depth =:= infinity; + is_integer(Depth), Depth >= 0 -> {ok, Depth}; - {value, {order, Order}} when is_function(Order), - is_function(Order, 2); - (Order =:= ascending); - (Order =:= descending) -> + {order, Order} when is_function(Order), is_function(Order, 2); + (Order =:= ascending); + (Order =:= descending) -> {ok, Order}; - {value, {compressed, Comp}} when Comp -> + {compressed, Comp} when Comp -> {ok, [compressed]}; - {value, {compressed, Comp}} when not Comp -> + {compressed, Comp} when not Comp -> {ok, []}; - {value, {tmpdir, T}} -> + {tmpdir, T} -> {ok, T}; - {value, {size, Size}} when is_integer(Size), Size > 0 -> + {size, Size} when is_integer(Size), Size > 0 -> {ok, Size}; - {value, {no_files, NoFiles}} when is_integer(NoFiles), - NoFiles > 1 -> + {no_files, NoFiles} when is_integer(NoFiles), NoFiles > 1 -> {ok, NoFiles}; - {value, {Key, _}} -> + {Key, _} -> badarg; false -> Default = default_option(Key), @@ -1457,7 +1446,7 @@ prep_qlc_lc({qlc_v1, QFun, CodeF, Qdata0, QOpt}, Opt, GOpt, _H) -> {?qual_data(QNum, GoI, SI, {gen, Prep}), ModGens} end, {Qdata, ModGens} = lists:mapfoldl(F, [], Qdata0), - SomeLookUp = lists:keymember(true, 2, ModGens) =/= false, + SomeLookUp = lists:keymember(true, 2, ModGens), check_lookup_option(Opt, SomeLookUp), case ModGens of [{_QNum, _LookUp, all, OnePrep}] -> @@ -1503,7 +1492,7 @@ pos_fun('==', QOpt, QNum) -> prep_gen(#qlc_table{lu_vals = LuV0, ms = MS0, trav_MS = TravMS, info_fun = IF, lookup_fun = LU_fun, - key_equality = KeyEquality}=LE0, + key_equality = KeyEquality}=LE0, Prep0, PosFun0, {MS, Fs}, Opt) -> PosFun = PosFun0(KeyEquality), {LuV, {STag,SkipFils}} = find_const_positions(IF, LU_fun, PosFun, Opt), @@ -1998,8 +1987,8 @@ no_cache_of_first_generator(Optz, 1) -> Optz#optz{cache = false}. maybe_sort(LE, QNum, DoSort, Opt) -> - case lists:keysearch(QNum, 1, DoSort) of - {value, {QNum, Col}} -> + case lists:keyfind(QNum, 1, DoSort) of + {QNum, Col} -> #qlc_opt{tmpdir = TmpDir, tmpdir_usage = TmpUsage} = Opt, SortOpts = [{tmpdir,Dir} || Dir <- [TmpDir], Dir =/= ""], Sort = #qlc_sort{h = LE, keypos = {keysort, Col}, unique = false, @@ -2025,7 +2014,7 @@ skip_lookup_filters(Qdata0, LU_SkipFs) -> %% specification it must be applied _after_ the lookup join (the %% filter must not be skipped!). activate_join_lookup_filter(QNum, Qdata) -> - {value, {_,GoI2,SI2,{gen,Prep2}}} = lists:keysearch(QNum, 1, Qdata), + {_,GoI2,SI2,{gen,Prep2}} = lists:keyfind(QNum, 1, Qdata), Table2 = Prep2#prepared.qh, NPrep2 = Prep2#prepared{qh = Table2#qlc_table{ms = no_match_spec}}, %% Table2#qlc_table.ms has been reset; the filter will be run. @@ -2059,7 +2048,7 @@ opt_join(Join, JoinOption, Qdata, Opt, LU_SkipQuals) -> opt_join_lu([{{_Q1,_C1,Q2,_C2}=J,[{lookup_join,_KEols,JKE,Skip0} | _]} | LJ], Qdata, LU_SkipQuals) -> - {value, {Q2,_,_,{gen,Prep2}}} = lists:keysearch(Q2, 1, Qdata), + {Q2,_,_,{gen,Prep2}} = lists:keyfind(Q2, 1, Qdata), #qlc_table{ms = MS, key_equality = KE, lookup_fun = LU_fun} = Prep2#prepared.qh, %% If there is no filter to skip (the match spec was derived @@ -2670,8 +2659,8 @@ sort_list_output(L) -> %% Don't use the file_sorter unless it is known that objects will be %% put on a temporary file (optimization). sort_handle(H, ListFun, FileFun, SortOptions, Post, LocalPost, TmpUsageM) -> - Size = case lists:keysearch(size, 1, SortOptions) of - {value, {size, Size0}} -> Size0; + Size = case lists:keyfind(size, 1, SortOptions) of + {size, Size0} -> Size0; false -> default_option(size) end, sort_cache(H, [], Size, {ListFun, FileFun, Post, LocalPost, TmpUsageM}). @@ -2891,8 +2880,8 @@ ucache_recall(UTab, MTab, SeqNo) -> Object = case ets:lookup(UTab, Hash) of [{Hash, SeqNo, Object0}] -> Object0; HashSeqObjects -> - {value, {Hash, SeqNo, Object0}} = - lists:keysearch(SeqNo, 2, HashSeqObjects), + {Hash, SeqNo, Object0} = + lists:keyfind(SeqNo, 2, HashSeqObjects), Object0 end, [Object | fun() -> ucache_recall(UTab, MTab, SeqNo + 1) end] @@ -3403,8 +3392,8 @@ merge_join_id() -> tmp_merge_file(MergeId) -> TmpFiles = get(?MERGE_JOIN_FILE), - case lists:keysearch(MergeId, 1, TmpFiles) of - {value, {MergeId, Fd, FileName}} -> + case lists:keyfind(MergeId, 1, TmpFiles) of + {MergeId, Fd, FileName} -> {Fd, FileName}; false -> none diff --git a/lib/stdlib/src/qlc_pt.erl b/lib/stdlib/src/qlc_pt.erl index 2d7874d99f..a72fe8639e 100644 --- a/lib/stdlib/src/qlc_pt.erl +++ b/lib/stdlib/src/qlc_pt.erl @@ -845,8 +845,8 @@ join_handle(AP, L, [F, H, O, C], Constants) -> join_handle_constants(QId, ExtraConstants) -> IdNo = QId#qid.no, - case lists:keysearch(IdNo, 1, ExtraConstants) of - {value, {IdNo, ConstOps}} -> + case lists:keyfind(IdNo, 1, ExtraConstants) of + {IdNo, ConstOps} -> ConstOps; false -> [] @@ -1231,9 +1231,9 @@ lu_skip(ColConstants, FilterData, PatternFrame, PatternVars, %% The filter can only be skipped if all constants %% are looked up. LookedUpConstants = - case lists:keysearch(Column, 1, ColConstants) of + case lists:keyfind(Column, 1, ColConstants) of false -> []; - {value, {Column,LUCs}} -> LUCs + {Column, LUCs} -> LUCs end, %% Don't try to handle filters that compare several %% values equal. See also frames_to_columns(). @@ -1279,8 +1279,8 @@ join_gens(Cs0, Qs, Skip) -> join_gens2(lists:filter(fun(C) -> length(C) > 2 end, Cs), FD, Skip)}. join_gens2(Cs0, FilterData, Skip) -> - [{J, skip_tag(case lists:keysearch(J, 1, Skip) of - {value, {J,FilL}} -> + [{J, skip_tag(case lists:keyfind(J, 1, Skip) of + {J, FilL} -> FilL; false -> [] @@ -1296,8 +1296,8 @@ skip_tag(FilList, FilterData) -> end, FilList}. skip_tag(Col, ColFils, FilterData) -> - case lists:keysearch(Col, 1, ColFils) of - {value, {Col, FilL}} -> + case lists:keyfind(Col, 1, ColFils) of + {Col, FilL} -> Tag = if length(FilterData) =:= length(FilL) -> all; @@ -1415,7 +1415,7 @@ sel_gf([], _N, _Deps, _RDs, _Gens, _Gens1) -> sel_gf([{#qid{no = N}=Id,{fil,F}}=Fil | FData], N, Deps, RDs, Gens, Gens1) -> case erl_lint:is_guard_test(F, RDs) of true -> - {value, {Id,GIds}} = lists:keysearch(Id, 1, Deps), + {Id,GIds} = lists:keyfind(Id, 1, Deps), case length(GIds) =< 1 of true -> case generators_in_scope(GIds, Gens1) of @@ -2572,8 +2572,8 @@ nos_pattern([P0 | Ps0], S0, PVs0) -> {[P | Ps], S, PVs}; nos_pattern({var,L,V}, {LI,Vs0,UV,A,Sg}, PVs0) when V =/= '_' -> {Name, Vs, PVs} = - case lists:keysearch(V, 1, PVs0) of - {value, {V,VN}} -> + case lists:keyfind(V, 1, PVs0) of + {V, VN} -> _ = used_var(V, Vs0, UV), {VN, Vs0, PVs0}; false -> -- cgit v1.2.3