Утка печатать в Delphi 2007?

С помощью ObjAuto.pas и типов вызываемых вариантов это должно быть возможно (написано в XE, но также должно работать в Delphi 7 или ниже):

unit DuckTyping;

interface

function Duck(Instance: TObject): Variant;

implementation

uses
  ObjAuto,
  SysUtils,
  TypInfo,
  Variants;

type
  TDuckVarData = packed record
    VType: TVarType;
    Reserved1, Reserved2, Reserved3: Word;
    VDuck: TObject;
    Reserved4: LongWord;
  end;

  TDuckVariantType = class(TPublishableVariantType)
  protected
    function GetInstance(const V: TVarData): TObject; override;
  public
    procedure Clear(var V: TVarData); override;
    procedure Copy(var Dest: TVarData; const Source: TVarData;
      const Indirect: Boolean); override;
    function DoFunction(var Dest: TVarData; const V: TVarData;
      const Name: string; const Arguments: TVarDataArray): Boolean; override;
  end;

var
  DuckVariantType: TDuckVariantType;

{ TDuckVariantType }

procedure TDuckVariantType.Clear(var V: TVarData);
begin
  V.VType := varEmpty;
  TDuckVarData(V).VDuck := nil;
end;

procedure TDuckVariantType.Copy(var Dest: TVarData; const Source: TVarData;
  const Indirect: Boolean);
begin
  if Indirect and VarDataIsByRef(Source) then
    VarDataCopyNoInd(Dest, Source)
  else
  begin
    with TDuckVarData(Dest) do
    begin
      VType := VarType;
      VDuck := TDuckVarData(Source).VDuck;
    end;
  end;
end;

function TDuckVariantType.DoFunction(var Dest: TVarData; const V: TVarData;
  const Name: string; const Arguments: TVarDataArray): Boolean;
var
  instance: TObject;
  methodInfo: PMethodInfoHeader;
  paramIndexes: array of Integer;
  params: array of Variant;
  i: Integer;
  ReturnValue: Variant;
begin
  instance := GetInstance(V);
  methodInfo := GetMethodInfo(instance, ShortString(Name));
  Result := Assigned(methodInfo);
  if Result then
  begin
    SetLength(paramIndexes, Length(Arguments));
    SetLength(params, Length(Arguments));
    for i := Low(Arguments) to High(Arguments) do
    begin
      paramIndexes[i] := i + 1;
      params[i] := Variant(Arguments[i]);
    end;

    ReturnValue := ObjectInvoke(instance, methodInfo, paramIndexes, params);
    if not VarIsEmpty(ReturnValue) then
      VarCopy(Variant(Dest), ReturnValue);
  end
  else
  begin
    VarClear(Variant(Dest));
  end;
end;

function TDuckVariantType.GetInstance(const V: TVarData): TObject;
begin
  Result := TDuckVarData(V).VDuck;
end;

function Duck(Instance: TObject): Variant;
begin
  TDuckVarData(Result).VType := DuckVariantType.VarType;
  TDuckVarData(Result).VDuck := Instance;
end;

initialization
  DuckVariantType := TDuckVariantType.Create;

finalization
  FreeAndNil(DuckVariantType);

end.

Вы можете просто использовать это так:

type
  {$METHODINFO ON}
  TDuck = class
  public // works in XE, not sure if it needs to be published in older versions
    procedure Quack;
  end;

procedure TDuck.Quack;
begin
  ShowMessage('Quack');
end;

procedure DoSomething(D: Variant);
begin
  D.Quack;
end;

var
  d: TDuck;
begin
  d := TDuck.Create;
  try
    DoSomething(Duck(d));
  finally
    d.Free;
  end;
end;

Быстрый ответ:

Не в значительном смысле

Более длинный ответ: согласно странице вики Duck Typing идентифицируется:

При утином наборе текста важны только те аспекты объекта, которые используются, а не тип самого объекта. Например, в языке без типа утки можно создать функцию, которая принимает объект типа Duck и вызывает методы walk и quack этого объекта. В языке с утиным типом эквивалентная функция будет принимать объект любого типа и вызывать методы walk и quack этого объекта. Если у объекта нет вызываемых методов, функция сигнализирует об ошибке времени выполнения.

Эквивалентный некомпилируемый код Delphi будет выглядеть так:

procedure DoSomething(D);
begin
  D.Quack;
end;

Я намеренно не указывал тип для D, потому что это противоречит цели. Delphi имеет статическую типизацию, так что это никогда не сработает. Если вам это нужно для небольшой функциональности, вы можете использовать Interfaces или RTTI и получить что-то вроде этого:

procedure DoSomething(D:TObject);
begin
  (D as ISomeIntf).Quack;
end;

Если вы можете получить RTTI:

procedure DoSomething(D:TObject);
begin
  CallQuackUsingRTTI(D);
end;

Я лично использовал метод RTTI для идентификации (и управления) объектами списка таким образом, чтобы код работал как с TList потомками, так и с общими TList<T> вариантами.

Вывод из этого должен быть следующим: даже с расширенными функциональными возможностями в новейших версиях Delphi (обобщенные и комплексные RTTI) вы приблизитесь к Duck typing только для ограниченной функциональности и со значительными усилиями. Этого просто нет в ДНК Delphi (потому что ДНК Delphi говорит о статической типизации), но вы могли бы получить что-то достаточно близкое, приложив много усилий и только для определенных функций. Может быть, если вы дадите нам представление о том, какая конкретная функциональность вам нужна, мы сможем что-то выяснить.

Вот идея, которая требует создания библиотеки типов.

Используйте типы OLE-автоматизации и реализуйте диспетчерские интерфейсы (двойные COM-объекты).

Теперь вы. Теперь вы можете писать все, что захотите, после этого типа, и мы узнаем во время выполнения, работает это или нет, или взорвется. Добро пожаловать в динамическую типизацию.

procedure DoSomething(D:OleVariant);
begin
  D.Quack; // Might work, might blow up.
end;

Я считаю это некрасивым, но другие могут и нет.