anchor.diff:      }
   
       return res + "${returnType})";
  +  }
  +  
  +  int get hashCode {
  +    int h = returnType.hashCode;
  +    for(Name name in namedParameterTypes.keys)
  +      h = h + name.hashCode + namedParameterTypes[name].hashCode;
  +    for(AbstractType t in normalParameterTypes)
  +      h = 31*h + t.hashCode;
  +    for(AbstractType t in optionalParameterTypes)
  +      h = 31*h + t.hashCode;
  +    return h;
     }
     
     bool operator ==(Object other) => 
  
positive.code:   TypeVariable();
    
    String toString() => types.toString();
  }
  
  class TypeMap {
    Map<Expression, TypeVariable> _typeMap = <Expression, TypeVariable>{};
    Map<Identifier, TypeVariable> _getters = <Identifier, TypeVariable>{};
    Map<Identifier, TypeVariable> _setters = <Identifier, TypeVariable>{};
    
    TypeVariable operator [](Expression e) => (containsKey(e) ? _typeMap[e] : addEmpty(e));
    
    bool containsKey(Expression e) => _typeMap.containsKey(e);
    TypeVariable addEmpty(Expression e) => _typeMap[e] = new TypeVariable();
    TypeVariable add(Expression e, TypeVariable type) => _typeMap[e] = type;
    
    void operator []=(Expression e, AbstractType t) {
      if (!_typeMap.containsKey(e))
        _typeMap[e] = new TypeVariable();
      _typeMap[e].add(t);
    }
    
    TypeVariable setter(Identifier i) {
      if (!_setters.containsKey(i))
        _setters[i] = new TypeVariable();
      return _setters[i];
    }
    
    TypeVariable getter(Identifier i) {
      if (!_getters.containsKey(i))
        _getters[i] = new TypeVariable();
      return _getters[i];
    }
    
    String toString() {
      StringBuffer sb = new StringBuffer();
      
      for(Expression exp in _typeMap.keys){
        sb.writeln("${exp}: ${_typeMap[exp]}");
      }
      
      return sb.toString();
    }
  }
  
  
  
negative.code:   }
  }
  
  
  /***************** TYPES **************/
  abstract class AbstractType {}
  
  class FreeType extends AbstractType {
    static int _countID = 0;
  