anchor.diff:  %%  test by checking the test and only adding one when we know the
   %%  test won't automatically return a boolean value.
   
  +comp_guard_test([quote,Bool], _, _, St) when is_boolean(Bool) ->
  +    {c_atom(Bool),St};                          %A small optimisation
   comp_guard_test([call,[quote,erlang],[quote,Op]|Args]=Test, Env, L, St) ->
       comp_guard_test_1(Test, Op, Args, Env, L, St);
   comp_guard_test([Op|Args]=Test, Env, L, St) ->
  -    comp_guard_test_1(Test, Op, Args, Env, L, St).
  +    comp_guard_test_1(Test, Op, Args, Env, L, St);
  +comp_guard_test(Symb, _, L, St) when is_atom(Symb) ->
  +    Ann = comp_gen_anno(L, St),
  +    {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), [c_var(Symb),c_atom(true)]),
  +     St};
  +comp_guard_test(_, _, _, St) ->
  +    %% Everything else always will always fail.
  +    {c_atom(false),St}.
   
   comp_guard_test_1(Test, Op, Args, Env, L, St0) ->
       Ar = length(Args),
  
positive.code:     Omega = c_var(omega),
      Ctrue = ann_c_clause([L], [True], Ctr),
      Cfalse = ann_c_clause([L], [False], Cfa),
      Cfail = ann_c_clause([L,compiler_generated], [Omega], Omega),
      {ann_c_case([L], Cte, [Ctrue,Cfalse,Cfail]),St3}.
  
  %% This produces code which is harder to optimise, strangely enough.
  
negative.code:     {Ccs,St2} = case_clauses(Cls, Env, L, St1),
      [_,Val,Info] = Cvs,
      Arg = c_tuple(Cvs),
      Fc = ann_c_clause(comp_gen_anno(L, St2),    %It is compiler generated
                        [Arg], raise_primop([Info,Val], L, St2)),
      Excp = ann_c_case([L], Arg, Ccs ++ [Fc]),
      {Cvs,Excp,St2}.
  