anchor.diff:  -spec execute(atom(), doko_utf8:str()) -> gb_set().
   execute(IndexId, Str) ->
       %% parse and preprocess query
  -    Clauses = [partition(flatten(X))||X <- clauses(dnf(from_str(Str)))],
  +    Clauses = [partition(flatten(X)) || X <- clauses(dnf(from_str(Str)))],
       %% translate keywords to terms
       UniqueKeywords =
  -        lists:usort(lists:map(fun (X) -> element(1, X) end,
  -                              lists:flatten([Xs++Ys||{Xs,Ys} <- Clauses]))),
  +        lists:usort(
  +          lists:map(fun (X) -> element(1, X) end,
  +                    lists:flatten([Xs ++ Ys || {Xs, Ys} <- Clauses]))),
       Translate =
           fun (Keyword) ->
                   Lang = doko_cluster:index_lang(IndexId),
                   Result = case doko_preprocessing:uterms(Keyword, Lang) of
  -                             []    -> stop_word;
  +                             [] -> stop_word;
                                Terms -> Terms
                            end,
  -                {Keyword,Result}
  +                {Keyword, Result}
           end,
       Terms = dict:from_list(lists:map(Translate, UniqueKeywords)),
       %% fetch data
       Fetch = fun (Term) -> {Term, doko_cluster:doc_ids(IndexId, Term)} end,
       UniqueTerms =
           lists:flatten(
  -          [Value||{_Key,Value} <- dict:to_list(Terms), Value /= stop_word]),
  +          [Value || {_, Value} <- dict:to_list(Terms), Value /= stop_word]),
       Data = dict:from_list(plists:map(Fetch, UniqueTerms)),
       %% calculate result
       DocIdsForZoneIds =
  
positive.code:     Destruct = fun (Q) ->
                         case Q of
                             #not_q{sub_q = S} ->
                                 {S#term_q.keyword,S#term_q.zone_ids};
                             #term_q{keyword = Keyword, zone_ids = ZoneIds} ->
                                 {Keyword, ZoneIds}
                         end
  
negative.code: not_element(#not_q{}) ->
      false.
  
  depth({and_q, L, R}) ->
      1 + max(depth(L), depth(R));
  depth({or_q,L,R}) ->
      1 + max(depth(L), depth(R));
  depth({not_q,Q}) ->
      1 + depth(Q);
  depth(_) ->
      0.
  
  prop_no_nested_or() ->
      ?FORALL(X, q(), not nested_or(dnf({X, depth(X)}))).
  
  nested_or({and_q, L, R}) ->
      (is_record(L, or_q) or is_record(R, or_q))
          orelse (nested_or(L) or nested_or(R));
  nested_or({or_q, L, R}) ->
      nested_or(L) or nested_or(R);
  nested_or({not_q, Q}) ->
      nested_or(Q);
  nested_or(_) ->
      false.
  