* Change to anonymous func

packages/rtl/generics.collections.pas

@@ -43,11 +43,12 @@ type
       AIndex, ACount: SizeInt): Boolean; virtual; abstract; overload;
     class function BinarySearch(const AValues: array of T; const AItem: T;
       out AFoundIndex: SizeInt; const AComparer: IComparer<T>): Boolean; overload;
-    //class function BinarySearch(const AValues: array of T; const AItem: T;
-    //  out AFoundIndex: SizeInt): Boolean; overload;
     class function BinarySearch(const AValues: array of T; const AItem: T;
       out ASearchResult: TBinarySearchResult; const AComparer: IComparer<T>): Boolean; overload;
-    //class function BinarySearch(const AValues: array of T; const AItem: T;
+    // No support for automatically creating a comparer.
+    //  class function BinarySearch(const AValues: array of T; const AItem: T;
+    //  out AFoundIndex: SizeInt): Boolean; overload;
+    //  class function BinarySearch(const AValues: array of T; const AItem: T;
     //  out ASearchResult: TBinarySearchResult): Boolean; overload;
   end;
 
@@ -204,7 +205,7 @@ implementation
 class procedure TCustomArrayHelper<T>.Sort(var AValues: array of T;
   const AComparer: IComparer<T>);
 begin
-  QuickSort(AValues, Low(AValues), High(AValues), AComparer);
+  QuickSort(AValues, 0, Length(AValues), AComparer);
 end;
 
 class procedure TCustomArrayHelper<T>.Sort(var AValues: array of T;
@@ -219,16 +220,18 @@ class function TCustomArrayHelper<T>.BinarySearch(const AValues: array of T;
   const AItem: T; out AFoundIndex: SizeInt; const AComparer: IComparer<T>
   ): Boolean;
 begin
+  Writeln('Here too',Length(aValues));
   Result := BinarySearch(AValues, AItem, AFoundIndex, AComparer,
-                         Low(AValues), High(AValues));
+                         0, Length(AValues));
 end;
 
 class function TCustomArrayHelper<T>.BinarySearch(const AValues: array of T;
   const AItem: T; out ASearchResult: TBinarySearchResult;
   const AComparer: IComparer<T>): Boolean;
 begin
+  Writeln('Here',Length(aValues));
   Result := BinarySearch(AValues, AItem, ASearchResult, AComparer,
-                         Low(AValues), High(AValues));
+                         0, Length(AValues));
 end;
 
 { TArrayHelper }
@@ -284,15 +287,20 @@ class function TArrayHelper<T>.BinarySearch(const AValues: array of T;
   const AItem: T; out ASearchResult: TBinarySearchResult;
   const AComparer: IComparer<T>; AIndex, ACount: SizeInt): Boolean;
 var
-  imin, imax, imid: Int32;
+  imin, imax, imid, ilo: Int32;
+
 begin
+  Writeln('Enter ',Length(aValues),' Idx ',aIndex,' acount: ',aCount);
   // continually narrow search until just one element remains
   imin := AIndex;
   imax := Pred(AIndex + ACount);
-
+  Writeln('Start Imax, imin : ',Imax, ' - ', imin);
+  ilo:=imid * imid;
+  imid:=ilo*imid;
   while (imin < imax) do
   begin
     imid := (imax+imin) div 2;
+    writeln('imid',imid);
 
     ASearchResult.CompareResult := AComparer.Compare(AValues[imid], AItem);
     // reduce the search
@@ -314,7 +322,7 @@ begin
   //   otherwise imax == imin
 
   // deferred test for equality
-
+  Writeln('End Imax, imin : ',Imax, ' - ', imin);
   if (imax = imin) then
   begin
     ASearchResult.CompareResult := AComparer.Compare(AValues[imin], AItem);

packages/rtl/generics.defaults.pas

@@ -11,12 +11,11 @@ type
 
   { IComparer }
 
-  IComparer<T> = interface
+  IComparer<T> = interface ['{505778ED-F783-4456-9691-32F419CC5E18}']
     function Compare(const Left, Right: T): Integer; overload;
   end;
 
-  TOnComparison<T> = function(const Left, Right: T): Integer of object;
-  TComparisonFunc<T> = function(const Left, Right: T): Integer;
+  TOnComparison<T> = reference to function(const Left, Right: T): Integer;
 
   { TComparer }
 
@@ -29,7 +28,6 @@ type
     function Compare(const ALeft, ARight: T): Integer; virtual; abstract; overload;
 
     class function Construct(const AComparison: TOnComparison<T>): IComparer<T>; overload;
-    class function Construct(const AComparison: TComparisonFunc<T>): IComparer<T>; overload;
   end;
 
   { TDefaultComparer }
@@ -49,16 +47,6 @@ type
     constructor Create(AComparison: TOnComparison<T>);
   end;
 
-  { TDelegatedComparerFunc }
-
-  TDelegatedComparerFunc<T> = class(TComparer<T>)
-  private
-    FComparison: TComparisonFunc<T>;
-  public
-    function Compare(const ALeft, ARight: T): Integer; override;
-    constructor Create(AComparison: TComparisonFunc<T>);
-  end;
-
   IEnumerator<T> = interface
     function GetCurrent: T;
     function MoveNext: Boolean;
@@ -84,13 +72,7 @@ end;
 class function TComparer<T>.Construct(const AComparison: TOnComparison<T>
   ): IComparer<T>;
 begin
-  Result := TDelegatedComparerEvents<T>.Create(AComparison);
-end;
-
-class function TComparer<T>.Construct(const AComparison: TComparisonFunc<T>
-  ): IComparer<T>;
-begin
-  Result := TDelegatedComparerFunc<T>.Create(AComparison);
+   Result := TDelegatedComparerEvents<T>.Create(AComparison);
 end;
 
 { TDefaultComparer }
@@ -115,20 +97,10 @@ end;
 
 constructor TDelegatedComparerEvents<T>.Create(AComparison: TOnComparison<T>);
 begin
+  Inherited create;
   FComparison := AComparison;
 end;
 
-{ TDelegatedComparerFunc }
-
-function TDelegatedComparerFunc<T>.Compare(const ALeft, ARight: T): Integer;
-begin
-  Result := FComparison(ALeft, ARight);
-end;
-
-constructor TDelegatedComparerFunc<T>.Create(AComparison: TComparisonFunc<T>);
-begin
-  FComparison := AComparison;
-end;
 
 end.