anchor.diff:  
   inner_check(Value, {list, InnerType}, ParseState) when is_list(Value) ->
       lists:all(fun (El) -> inner_check(El, InnerType, ParseState) end, Value);
  -inner_check(_Value, {typedef, tester, test_any}, ParseState) ->
  +inner_check(_Value, {typedef, tester, test_any}, _ParseState) ->
       true;
   inner_check(Value, {typedef, Module, TypeName}, ParseState) ->
       case tester_parse_state:lookup_type({type, Module, TypeName}, ParseState) of
  
positive.code:         {value, Type} ->
              inner_check(Value, Type, ParseState)
      end;
  inner_check(Value, {tuple, {typedef, tester, test_any}}, ParseState) when is_tuple(Value) ->
      true;
  inner_check(Value, {tuple, TupleType}, ParseState) when is_tuple(Value) ->
      case erlang:size(Value) =:= erlang:length(TupleType) of
  
negative.code:     %ct:pal("inner check union ~p~n", [TypeList]),
      lists:any(fun (Type) -> inner_check(Value, Type, ParseState) end, TypeList);
  
  inner_check(Value, {range, {integer, Min}, {integer, Max}}, _ParseState) when is_integer(Value) ->
      (Min =< Value) andalso (Max >= Value);
  
  inner_check(Value, bool, _ParseState) when is_boolean(Value) ->
      true;
  inner_check(Value, integer, _ParseState) when is_integer(Value) ->
      true;
  inner_check(Value, {atom, AtomValue}, _ParseState) when is_atom(Value) ->
      Value == AtomValue;
  
  inner_check(_Value, _Type, _ParseState) ->
      %ct:pal("failed inner_check(~w, ~w)", [Value, Type]),
      false.
  
  check_tuple_type(Value, [NextType | Rest] = _TupleType, ParseState, Idx) ->
      %ct:pal("check_tuple_type(~w, ~w)", [Value, _TupleType]),
      inner_check(erlang:element(Idx, Value), NextType, ParseState)
          andalso
          check_tuple_type(Value, Rest, ParseState, Idx + 1);
  check_tuple_type(Value, [], _ParseState, Idx) ->
      erlang:tuple_size(Value) + 1 == Idx.
  
  