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.

5 files changed, 111 insertions, 124 deletions

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 ->