anchor.diff:  %%
   %% @see constraint/2
   
  --spec constraint_body(syntaxTree()) -> syntaxTree().
  +-spec constraint_body(syntaxTree()) -> [syntaxTree()].
   
   constraint_body(Node) ->
       case unwrap(Node) of
  -        {type, _, constraint, [_, Type]} ->
  -            Type;
  +        {type, _, constraint, [_, Types]} ->
  +            Types;
           Node1 ->
  -            (data(Node1))#constraint.type
  +            (data(Node1))#constraint.types
       end.
   
   
  
positive.code: %% @see constraint_body/1
  
  -record(constraint, {name :: syntaxTree(),
                       type :: syntaxTree()}).
  
  %% type(Node) = constraint
  %% data(Node) = #constraint{name :: Name,
  %%                          type :: Type}
  %%
  %%      Name = syntaxTree()
  %%      Type = syntaxTree()
  %%
  %% `erl_parse' representation:
  %%
  %% {type, Pos, constraint, [{atom, Pos, is_subtype}, Name, Type]}
  %%
  %%      Name = erl_parse()
  %%      Type = erl_parse()
  
  -spec constraint(syntaxTree(), syntaxTree()) -> syntaxTree().
  
  constraint(Name, Type) ->
      tree(constraint,
           #constraint{name = Name, type = Type}).
  
  revert_constraint(Node) ->
      Pos = get_pos(Node),
      Name = constraint_argument(Node),
      Type = constraint_body(Node),
      {type, Pos, constraint, [Name, Type]}.
  
  
  %% =====================================================================
  
negative.code: %% @see function_type/1
  %% @see function_type/2
  
  -spec function_type_arguments(syntaxTree()) -> any_arity | [syntaxTree()].
  
  function_type_arguments(Node) ->
      case unwrap(Node) of
  