anchor.diff:  % component matching patterns
   %
   
  -fold({}) -> "";
  -fold([]) -> "";
  +% Empty list or tuples
  +fold(X) when X =:= {}; X =:= [] -> "";
  +
  +% All option and optionlist and its variants
   fold({'identified globally', E}) -> " identified globally " ++ fold(E);
   fold({'identified extern', E}) -> " identified externally " ++ fold(E);
   fold({'identified by', Pswd}) -> " identified by " ++ binary_to_list(Pswd);
  
positive.code:     end
      || A <- Args], " || ");
  
  fold({as, A, B}) when is_binary(A), is_binary(B) -> lists:flatten([binary_to_list(A), " ", binary_to_list(B)]);
  fold({as, A, B}) when is_binary(B)               -> lists:flatten([fold(A), " ", binary_to_list(B)]);
  fold({as, A}) when is_binary(A)                  -> lists:flatten(["as ", binary_to_list(A)]);
  fold({union, A, B})                              -> lists:flatten(["(", fold(A), " union ", fold(B), ")"]);
  
  fold({where, []}) ->                                                "";
  fold({where, Where}) ->                                             "where " ++ fold(Where);
  
  fold({'in', L, {'list', _} = R}) when is_binary(L) ->
      lists:flatten([binary_to_list(L), " in ", fold(R), " "]);
  fold({'in', L, R}) when is_binary(L), is_tuple(R) ->
      lists:flatten([binary_to_list(L), " in (", fold(R), ") "]);
  
  fold({Op, L, R}) when is_atom(Op), is_tuple(L), is_tuple(R) ->
      Fl = case {Op, element(1, L)} of
          {'*', Ol} when Ol =:= '-'; Ol =:= '+' -> lists:flatten(["(", fold(L), ")"]);
  
negative.code:     end,
      lists:flatten([Fl, " ", atom_to_list(Op), " ", binary_to_list(R)]);
  fold({Op, L, R}) when is_atom(Op), is_binary(L), is_binary(R) ->    lists:flatten([binary_to_list(L), " ", atom_to_list(Op), " ", binary_to_list(R)]);
  
  % Unary - and 'not' operators
  fold({Op, A}) when Op =:= '-'; Op =:= 'not' ->
      case A of
          A when is_binary(A) -> lists:flatten([atom_to_list(Op), " (", binary_to_list(A), ")"]);
          A                   -> lists:flatten([atom_to_list(Op)," (", fold(A), ")"])
      end;
  
  % funs
  fold({'fun', N, Args}) when is_atom(N) ->
      atom_to_list(N) ++ "(" ++
      string:join(
  