Search a Generic list sing a Search String , ERROR E2034 TOO MAN PARAMETER

Question

I guess my understanding of the way of writing code is still very limited. I try to modify the solution from SEARCH GENERIC LISTS, but I can not change the code in a way that he is accepting arbitrary key words as a search parameter

unit Unit_TsearchableTList;

interface

uses Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.Buttons,
  contnrs, Generics.Collections;

type
  TSearchableObjectList<T: class> = class(TObjectList<T>)

  public type
    TPredicate = reference to function(aItem: T; asearchValue: String): boolean;
  public
    function search(aFound: TPredicate<T>; asearchValue: String): T;
  end;

implementation

function TSearchableObjectList<T>.search(aFound: TPredicate<T>;
  asearchValue: String): T;
var
  item: T;
begin
  for item in Self do
    * * * * * * * * COMPILE ERROR IS HERE * * * * * * * * * * * * * * * *
      * ! ! ! ! ! !
  if aFound(item, asearchValue) then
    Exit(item);
  Result := nil;
end;

end.

Usage example:

type
  TReplaceElementNames = class
    FindName: String;
    ReplaceName: String;
    ReplacementCondition: TReplacementCondition; // not relevant code
  end;

var
  LookUpList: TList<TReplaceElementNames>;
  search    : TReplaceElementNames;

begin
  LookUpList := TSearchableObjectList<TReplaceElementNames>.Create;

  search := LookUpList.search(
    function(aItem: TReplaceElementNames; searchname: String): boolean
    begin
      Result := aItem.FindName = searchname;
    end);

Answer 1

The type that you defined in your code is TPredicate. But you then went on to use TPredicate<T> which is a type defined in SysUtils. Simply replace

TPredicate<T>

with

TPredicate

in your code, and it will compile.

---

Having said that, it would be simpler if you used the code in the answer you accepted. There's no need for a two parameter predicate since variable capture is used to provide the search string.

Answer 2

By definition, predicate is somethign, that only takes one parameter like http://docwiki.embarcadero.com/Libraries/XE2/en/System.SysUtils.TPredicate

So, how can we pas more parameters to it, like what to compare against ? We do it by capturing the ocntext and generating new temporary function with that context fixed.

• http://en.wikipedia.org/wiki/Closure_(computer_science)
• http://en.wikipedia.org/wiki/Currying

Modifying your example that would be (i try to be verbose, so you can track the steps):

Type CanCompareWithString<T> = function (const Value:T; const Target: string): boolean;
// overcoming Delphi limitation

Function CreatePredicateFunction<T>(Const Target: String; Const Matcher: CanCompareWithString<T>): TPredicate<T>;
begin
   Result := function // creating new function (more correct: new closure)
                (Arg1: T): Boolean // see top link to Delphi docs
                begin
                  Result := 
                     Matcher // capturing the passed function
                     ( Arg1, 
                       Target ) // capturing the target value
                end;    // finished creating closure
    end;


  TSearchableObjectList<T: class> = class(TObjectList<T>)
  public
    function search(aFound: TPredicate<T>): T; overload;
    function search( asearchValue: String; Matcher: CanCompareWithString<T>): T; overload;
  end;

function TSearchableObjectList<T>.search(aFound: TPredicate<T>): T;
var
  item: T;
begin
  for item in Self do
  if aFound(item) then
    Exit(item);
  Result := Default(T);
end;

function TSearchableObjectList<T>.search( asearchValue: String;  Matcher: CanCompareWithString<T>): T;
begin
  Result := 
    Search(
       CreatePredicateFunction(
           Matcher, aSearchValue)
    ); 
end;

How can you use it ? Hopefully something like that:

function StringMatcher(const Value:string; const Target: string): boolean;
begin
   Result := Value = Target;
end;

var L_S : TSearchableObjectList<String>; S: String;

S := L_S.Search('abcde', StringMAtcher);

Now you may ask "Why ? Why that StringMatcher at all?"

And the problem is that in Delphi you cannot add partial constraints on operators with types (what in Scala is called exisential types AFAIR). You just cannot compile

function Equal<T>(const value: String): boolean;
begin
  Result := T = Value;
end;

function Sum<U>(const value1, value2: U): U;
begin
  Result := value1 + value2;
end;

Delphi does not now what that type T would be and cannot ensure whether it can or cannot be compared to string, thus it would NOT be able to compile that "T = Value".

Delphi does not now what that type U would be and cannot ensure whether it can or cannot be added, thus it would NOT be able to compile that "value1 + value2".

It is a big limitation - but that is how it is.

Look at the implementations of the following to types:

• http://docwiki.embarcadero.com/Libraries/XE4/en/System.Generics.Defaults.IEqualityComparer.Equals
• http://docwiki.embarcadero.com/Libraries/XE2/en/System.Generics.Defaults.TStringComparer

And you would see which kind of boilerplate is required to do a somewhat similar task (but easier one! there the task is just to compare T to T, not T to String).