Commit equality to shared collections

Question

Suppose you have a record with an overloaded equality operator

TSomeRecord = record Value : String; class operator Equal(Left, Right : TSomeRecord) : Boolean; end; 

(implementation compares string values). If you add two entries to the list, equal based on the overloaded operator, I expect the Contains method to return true in both cases. But in fact, the general list seems to simply compare the contents of the record memory instead of using the overloaded equality operator.

 var List : TList <TSomeRecord>; Record1, Record2 : TSomeRecord; begin Record1.Value := 'ABC'; Record2.Value := 'ABC'; List.Add(Record1); Assert(List.Contains(Record1)); Assert(List.Contains(Record2)); // <--- this is not true end; 

Is this the expected behavior? Any explanations?

Answer 1

Assuming you did not specify a TList.Create constructor in the constructor, you will get TComparer<TSomeRecord>.Default as your comparator. And this is a CompareMem that performs simple binary comparisons using CompareMem .

This is great for writing full value types, without padding. But otherwise, you will need to provide your own comparison function when creating the list instance.

If you want to see the details, the default mapping for records is implemented in Generics.Defaults . For large records, the comparison is this function:

 function Equals_Binary(Inst: PSimpleInstance; const Left, Right): Boolean; begin Result := CompareMem(@Left, @Right, Inst^.Size); end; 

For smaller entries, there is optimization, and your companion will be a 4-byte comparator. It looks like this:

 function Equals_I4(Inst: Pointer; const Left, Right: Integer): Boolean; begin Result := Left = Right; end; 

This is a bit strange, but it interprets 4 bytes of your record as an integer of 4 bytes and performs an integer equality comparison. In other words, the same as CompareMem , but more efficient.

The component you want to use might look like this:

 TComparer<TSomeRecord>.Construct( function const Left, Right: TSomeRecord): Integer begin Result := CompareStr(Left.Value, Right.Value); end; ) 

Use CompareText if you want case insensitive and so on. I used an ordered comparison function because this is what TList<T> wants.

The fact that comparing records by default is a comparison of equality suggests that attempts to sort record lists without specifying your own comparator will have unexpected results.

Given that the default mapper uses comparison comparisons, you say that it would be inappropriate to use such a comparator:

 TComparer<TSomeRecord>.Construct( function const Left, Right: TSomeRecord): Integer begin Result := ord(not (Left = Right)); end; ) 

This will be fine for unordered operations such as IndexOf or Contains , but is not explicitly used for sorting, binary search, etc.

Answer 2

To get the expected behavior, you need to create a List using a comparator.

In this case you should use

 List := TList<TSomeRecord>.Create( TComparer<TSomeRecord>.Construct( function ( const L, R : TSomeRecord ) : Integer begin Result := CompareStr( L.Value, R.Value ); end ) );