Iteradores e corrotinas

program Iterators;
// Demo: geradores com `iterator function` + `yield` (máquina de estados, sem pilha própria).
// Cada `yield` entrega um valor ao laço `for ... in` e suspende a função até o próximo passo.
// Os valores são produzidos SOB DEMANDA: dá para ter sequências enormes (ou infinitas) sem memória.

uses System.Remainder, Fenner.Iterators;   // o Iterators.config põe Compiler\extras no SourcePath

type
  TNode = class(TObject)
  public
    Value: Int32;
    Left, Right: TNode;
    constructor Create(const AValue: Int32);
    destructor Destroy; override;
  end class;

  TGen = class(TObject)
  public
    iterator function Squares(ACount: Int32): Int32;
    iterator function Collatz(AStart: Int32): Int32;
    iterator function InOrder(const ANode: TNode): Int32;
  end class;

constructor TNode.Create(const AValue: Int32);
begin
  inherited Create;
  Value := AValue;
end constructor;

destructor TNode.Destroy;
begin
  Left.Free;
  Right.Free;
  inherited Destroy;
end destructor;

function Insert(const ARoot: TNode; const AValue: Int32): TNode;
begin
  if ARoot = nil then
    Exit(TNode.Create(AValue));
  if AValue < ARoot.Value then
    ARoot.Left := Insert(ARoot.Left, AValue)
  else
    ARoot.Right := Insert(ARoot.Right, AValue);
  Result := ARoot;
end function;

iterator function TGen.Squares(ACount: Int32): Int32;
var
  I: Int32;
begin
  for I := 1 to ACount do
    yield I * I;                  // entrega um valor e suspende aqui
end function;

// A sequência de Collatz: o laço guarda seu estado entre um yield e outro.
iterator function TGen.Collatz(AStart: Int32): Int32;
var
  X: Int32;
begin
  X := AStart;
  repeat
    yield X;
    if (X mod 2) = 0 then X := X div 2 else X := 3 * X + 1;
  until X = 1;
  yield 1;
end function;

// `yield from` delega para outro gerador: percurso em ordem de uma árvore, recursivo.
iterator function TGen.InOrder(const ANode: TNode): Int32;
begin
  if ANode = nil then
    Exit;
  yield from InOrder(ANode.Left);
  yield ANode.Value;
  yield from InOrder(ANode.Right);
end function;

var
  LGen: TGen;
  LRoot: TNode;
  LIter: TIterator<Int32>;
  LValues: array of Int32;
  X, LTotal: Int32;
begin
  LGen := TGen.Create;

  Write('quadrados:');
  for X in LGen.Squares(5) do Write(' ', X);
  WriteLn;

  Write('Collatz de 6:');
  for X in LGen.Collatz(6) do Write(' ', X);
  WriteLn;

  LValues := [50, 30, 70, 20, 40, 60, 80];
  LRoot := nil;
  for X in LValues do
    LRoot := Insert(LRoot, X);
  Write('árvore em ordem:');
  for X in LGen.InOrder(LRoot) do Write(' ', X);
  WriteLn;

  // uso manual: MoveNext avança, Current lê. Quem cria o iterador manualmente o libera.
  LIter := LGen.Squares(1000000);        // um milhão de quadrados... que nunca serão calculados
  LTotal := 0;
  while LIter.MoveNext do
  begin
    LTotal := LTotal + LIter.Current;
    if LIter.Current > 50 then Break;    // parar cedo é barato: o resto nem existe
  end while;
  WriteLn('soma até passar de 50: ', LTotal);
  LIter.Free;

  LRoot.Free;
  LGen.Free;
end.

Platform MSWin64
Default Platform MSWin64
Mode Debug
Default Mode Debug
PlatformMode All * *
PlatformMode MSWin64Debug MSWin64 Debug
Config All SourcePath ($FcPath)\..\extras

program Coroutines;
// Demo: corrotinas "stackful" (Fenner.Coroutines). Cada corrotina tem a SUA pilha, então ela pode
// suspender (Yield) de qualquer profundidade de chamada, inclusive dentro de recursão.
// Diferença para o `iterator function`: aqui o Yield é um método comum e pode estar numa rotina auxiliar.
// Limitação: só funciona em Windows 64 bits (TCoroutine.IsSupported diz se há suporte).

uses System.Remainder, Fenner.Coroutines;   // o Coroutines.config põe Compiler\extras no SourcePath

type
  TNode = class(TObject)
  public
    Value: Int32;
    Left, Right: TNode;
    constructor Create(const AValue: Int32);
    destructor Destroy; override;
  end class;

constructor TNode.Create(const AValue: Int32);
begin
  inherited Create;
  Value := AValue;
end constructor;

destructor TNode.Destroy;
begin
  Left.Free;
  Right.Free;
  inherited Destroy;
end destructor;

function Insert(const ARoot: TNode; const AValue: Int32): TNode;
begin
  if ARoot = nil then
    Exit(TNode.Create(AValue));
  if AValue < ARoot.Value then
    ARoot.Left := Insert(ARoot.Left, AValue)
  else
    ARoot.Right := Insert(ARoot.Right, AValue);
  Result := ARoot;
end function;

// Rotina RECURSIVA comum que faz Yield no meio: um `iterator function` precisaria de `yield from`,
// mas aqui é só uma chamada de método, em qualquer profundidade.
procedure Walk(const ANode: TNode; const AGen: TGenerator<Int32>);
begin
  if ANode = nil then
    Exit;
  Walk(ANode.Left, AGen);
  AGen.Yield(ANode.Value);
  Walk(ANode.Right, AGen);
end procedure;

function Squares(const ACount: Int32): TGenerator<Int32>;
begin
  Result := TGenerator<Int32>.Create(
    procedure(const AGen: TGenerator<Int32>);
    var
      I: Int32;
    begin
      for I := 1 to ACount do
        AGen.Yield(I * I);
    end);
end function;

var
  LGen: TGenerator<Int32>;
  LRoot: TNode;
  LValues: array of Int32;
  X, LTotal: Int32;
begin
  WriteLn('suporte a corrotinas: ', TCoroutine.IsSupported);

  LGen := Squares(6);
  Write('quadrados:');
  for X in LGen do Write(' ', X);
  WriteLn;
  LGen.Free;

  LValues := [50, 30, 70, 20, 40, 60, 80];
  LRoot := nil;
  for X in LValues do
    LRoot := Insert(LRoot, X);
  LGen := TGenerator<Int32>.Create(
    procedure(const AGen: TGenerator<Int32>);
    begin
      Walk(LRoot, AGen);
    end);
  Write('árvore em ordem:');
  for X in LGen do Write(' ', X);
  WriteLn;
  LGen.Free;

  // Parar no meio: o Free CANCELA a corrotina suspensa e libera o que ela segurava.
  LGen := Squares(1000000);
  LTotal := 0;
  for X in LGen do
  begin
    LTotal := LTotal + X;
    if X > 50 then Break;
  end for;
  WriteLn('soma até passar de 50: ', LTotal);
  LGen.Free;
  LRoot.Free;
end.

Platform MSWin64
Default Platform MSWin64
Mode Debug
Default Mode Debug
PlatformMode All * *
PlatformMode MSWin64Debug MSWin64 Debug
Config All SourcePath ($FcPath)\..\extras