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