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:     
    
    NominalType(ClassElement this.element, ConstraintAnalysis this.constraintAnalysis);
    
    //TODO (jln): Make lookup on the classElement first. 
    TypeVariable property(String name) {
      if (!properties.containsKey(name)){
        properties[name] = new TypeVariable();
        
        ClassMember member = this.element.lookup(new Name(name));
        if (member != null)
          properties[name].add(constraintAnalysis.elementTyper.typeClassMember(member, this.element.sourceElement.library));
      }
      return properties[name];
    }
    
    String toString() => element.name.toString();
    
    bool operator ==(Object other) => other is NominalType && other.element == this.element;
    
    int get hashCode => element.hashCode;
  }
  
  class VoidType extends AbstractType {
  
negative.code:   
    String toString() => "\u{03b1}${_typeID}";
    
    //TODO (jln): a free type is equal to any free type right?
    //bool operator ==(Object other) => other is FreeType;
  }
  
  class FunctionType extends AbstractType {
    List<AbstractType> normalParameterTypes;
    List<AbstractType> optionalParameterTypes;
    Map<Name, AbstractType> namedParameterTypes;
    AbstractType returnType;
    
    FunctionType(List<AbstractType> this.normalParameterTypes, AbstractType this.returnType, 
                [List<AbstractType> optionalParameterTypes = null, Map<Name, AbstractType> namedParameterTypes = null ] ) :
  