anchor.diff:  
   type_is_defined(TypeOrOpaque, Name, Arity, RecDict) ->
     dict:is_key({TypeOrOpaque, Name, Arity}, RecDict).
  +
  +cannot_have_opaque(Type, TypeName, TypeNames) ->
  +  t_is_none(Type) orelse is_recursive(TypeName, TypeNames).
  +
  +is_recursive(TypeName, TypeNames) ->
  +  lists:member(TypeName, TypeNames).
   
   can_unfold_more(TypeName, TypeNames) ->
     Fun = fun(E, Acc) -> case E of TypeName -> Acc + 1; _ -> Acc end end,
  
positive.code:           false -> {t_any(), L1}
          end,
        Rep1 = choose_opaque_type(Rep, Type),
        Rep2 = case t_is_none(Rep1) of
                 true -> Rep1;
                 false ->
                   ArgTypes2 = subst_all_vars_to_any_list(ArgTypes),
  
negative.code:                     case can_unfold_more(RemType, TypeNames) of
                        true ->
                          NewTypeNames = [RemType|TypeNames],
                          Site = RemType,
                          t_from_form(Form, NewTypeNames, ET, Site, MR,
                                      TmpVarDict, D, L1);
                        false -> {t_any(), L1}
                      end,
                    NewRep1 = choose_opaque_type(NewRep, Type),
                    NewRep2 =
                      case cannot_have_opaque(NewRep1, RemType, TypeNames) of
                        true -> NewRep1;
                       false ->
                         ArgTypes2 = subst_all_vars_to_any_list(ArgTypes),
                         t_opaque(Mod, Name, ArgTypes2, NewRep1)
                      end,
                    {NewRep2, L2};
                  error ->
                    Msg = io_lib:format("Unable to find remote type ~w:~w()\n",
  