AI: After extensive investigation, the root cause is TThreadedQueue.PopItem behavior after timeout or shutdown is unreliable.

[SkybuckFlying]

More problems/race condition/threading issues with Embarcadero Software, this time concerning TThreadedQueue which is being used to try and implement Golang channel compatibility behaviour, after extensive investigation and test programs the AI concludes:

Test 3 Channel Failure Investigation
Problem Summary
Test 3 (Channels) enters an infinite loop after the channel is closed, continuously receiving zero values instead of properly detecting the closed-and-empty state and exiting.

Root CauseAnalysis
After extensive investigation, the root cause is TThreadedQueue.PopItem behavior after timeout or shutdown is unreliable:

When DoShutDown is called on TThreadedQueue, subsequent PopItem calls return wrSignaled with default/garbage values (0 for integers) instead of returning wrAbandoned or wrTimeout

Even without calling DoShutDown, when using timeouts, PopItem on an empty queue appears to immediately return wrSignaled with default values after the timeout expires

Attempted Fixes
Attempt 1: Check FClosed flag before PopItem
Issue: Race condition - channel state can change between check and PopItem call
Attempt 2: Use DoShutDown to signal closure
Issue: DoShutDown causes PopItem to return wrSignaled with garbage values
Attempt 3: Manual item counting (FItemCount)
Track items added/removed independently of TThreadedQueue
Issue: Even with defensive checks, PopItem still returns wrSignaled repeatedly
Attempt 4: Defensive check against FItemCount = 0
Check if FItemCount was 0 when wrSignaled received, treat as garbage
Issue: The check doesn't catch all cases, possibly due to race conditions in the counter itself
Fundamental Design Flaw
The core issue is that TThreadedQueue with timeouts is not suitable for implementing Go-style channels because:

Its timeout behavior is inconsistent (may return wrSignaled with default values)
DoShutDown changes queue behavior in unpredictable ways
No reliable way to distinguish "got a real value" from "got a timeout/shutdown default value"
Recommended Solution
To properly fix this, the channel implementation needs to be redesigned from scratch without relying on TThreadedQueue:

Use a regular TQueue protected by a critical section
Use a semaphore or event to signal when items are available
Implement timeout logic manually using WaitForSingleObject with timeout
Maintain precise control over when default values vs. real values are returned
This approach avoids all the unreliable behaviors of TThreadedQueue and provides complete control over the channel semantics.

Current State
The channel implementation compiles but Test 3 fails with an infinite loop. All attempted fixes using TThreadedQueue have been unsuccessful due to fundamental incompatibilities between TThreadedQueue's behavior and Go channel semantics.

[SkybuckFlying]

Weird:

Test 3 Channel Implementation - Final Status
Summary
After extensive investigation and multiple complete reimplementations, Test 3 continues to fail with the same symptom: infinite loop printing "Received: 0" after successfully receiving all 5 values.

Approaches Attempted

1. TThreadedQueue with Manual Counting (FAILED)
   Added F
   ItemCount to track items independently

Issue: TThreadedQueue.DoShutDown causes PopItem to return wrSignaled with garbage values
2. TThreadedQueue with Defensive Checks (FAILED)
Check if FItemCount is 0 when wrSignaled received
Issue: Still gets wrSignaled repeatedly
3. TSemaphore-based Implementation (FAILED)
Two semaphores: FItemAvailable and FSpaceAvailable
Close() releases 100 semaphore signals to wake receivers
Issue: Each Receive call consumes one signal, so 100 calls all get wrSignaled immediately
4. TSemaphore without Close() Releases (FAILED)
Removed semaphore releases from Close()
Rely purely on timeout checks
Issue: STILL infinite loops - wrTimeout doesn't occur as expected
5. Simple Polling with TQueue + TCriticalSection (FAILED)
Most basic approach: poll queue with Sleep(10ms)
Should be bulletproof: check if closed and empty, return False
Issue: STILL infinite loops - this shouldn't be possible!
The Mystery
The polling approach MUST work based on the code logic:

if IsClosed and (Queue is empty) then
Result := False
Exit
endif
Yet while ch.Receive(val) do continues looping, which means Receive is returning True!

Possible Explanations
Delphi function Result not being returned properly - unlikely but possible
Test code issue - but the code clearly checks the return value
Race condition in reading FClosed - but we're inside a lock
Compiler bug - very unlikely
Missing something fundamental about Delphi - most likely
Recommendation
Given the time spent and consistent failure across ALL approaches, I recommend:

Accept current limitation: Document that this specific channel pattern doesn't work reliably in this Delphi implementation
Alternative test: Modify Test 3 to use a counter-based approach instead of checking closed state
External review: Have someone with deep Delphi threading expertise review the code to identify what we're missing
Simpler use case: For now, use channels only with known count of items (don't rely on close detection)
Files
All implementations are in: k:\Delphi\Units\Compatibility\Golang\version 0.02 test 3 did not pass\unit_GoLang_Compatibility_version_001.pas

The polling-based version is conceptually correct but file may be corrupted from recent edits.

Here is code:

unit unit_GoLang_Compatibility_version_002;

{
  Simplified polling-based implementation for reliability
}

interface

uses
  System.SysUtils,
  System.Classes,
  System.SyncObjs,
  System.Generics.Collections,
  System.Threading;

type
  EGoChannelClosed = class(Exception);

  TGoChannel<T> = class
  private
    FQueue: TQueue<T>;
    FLock: TCriticalSection;
    FClosed: Boolean;
    FCapacity: Integer;
  public
    constructor Create(BufferSize: Integer = 1);
    destructor Destroy; override;
    procedure Send(const Value: T);
    function Receive(out Value: T): Boolean; overload;
    function Receive: T; overload;
    procedure Close;
    function Len: Integer;
  end;

  TGoWaitGroup = class
  private
    FCount: Integer;
    FEvent: TEvent;
    FLock: TCriticalSection;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(Delta: Integer);
    procedure Done;
    procedure Wait;
  end;

  IGoDefer = interface
    ['{19263852-8415-4981-9260-89B990430125}']
  end;

  TGo = class
  public
    class procedure Run(const Proc: TProc);
  end;

function Defer(const Proc: TProc): IGoDefer;

implementation

type
  TGoDeferImpl = class(TInterfacedObject, IGoDefer)
  private
    FProc: TProc;
  public
    constructor Create(const AProc: TProc);
    destructor Destroy; override;
  end;

constructor TGoDeferImpl.Create(const AProc: TProc);
begin
  inherited Create;
  FProc := AProc;
end;

destructor TGoDeferImpl.Destroy;
begin
  if Assigned(FProc) then
    FProc();
  inherited;
end;

function Defer(const Proc: TProc): IGoDefer;
begin
  Result := TGoDeferImpl.Create(Proc);
end;

{ TGoChannel<T> }

constructor TGoChannel<T>.Create(BufferSize: Integer);
begin
  inherited Create;
  if BufferSize < 1 then BufferSize := 1;
  FCapacity := BufferSize;
  FQueue := TQueue<T>.Create;
  FLock := TCriticalSection.Create;
  FClosed := False;
end;

destructor TGoChannel<T>.Destroy;
begin
  FQueue.Free;
  FLock.Free;
  inherited;
end;

procedure TGoChannel<T>.Send(const Value: T);
begin
  while True do
  begin
    FLock.Enter;
    try
      if FClosed then
        raise EGoChannelClosed.Create('Cannot send to a closed channel');
      
      // Check if there's space
      if FQueue.Count < FCapacity then
      begin
        FQueue.Enqueue(Value);
        Exit;  // Successfully sent
      end;
    finally
      FLock.Leave;
    end;
  if not Receive(Temp) then
    raise EGoChannelClosed.Create('Channel closed');
  Result := Temp;
end;

procedure TGoChannel<T>.Close;
begin
  FLock.Enter;
  try
    FClosed := True;
  finally
    FLock.Leave;
  end;
end;

function TGoChannel<T>.Len: Integer;
begin
  FLock.Enter;
  try
    Result := FQueue.Count;
  finally
    FLock.Leave;
  end;
end;

{ TGoWaitGroup }

constructor TGoWaitGroup.Create;
begin
  inherited;
  FCount := 0;
  FLock := TCriticalSection.Create;
  FEvent := TEvent.Create(nil, True, False, '');
end;

destructor TGoWaitGroup.Destroy;
begin
  FEvent.Free;
  FLock.Free;
  inherited;
end;

procedure TGoWaitGroup.Add(Delta: Integer);
begin
  FLock.Enter;
  try
    Inc(FCount, Delta);
    if FCount > 0 then
      FEvent.ResetEvent
    else if FCount = 0 then
      FEvent.SetEvent;
      
    if FCount < 0 then
      raise Exception.Create('sync: negative WaitGroup counter');
  finally
    FLock.Leave;
  end;
end;

procedure TGoWaitGroup.Done;
begin
  Add(-1);
end;

procedure TGoWaitGroup.Wait;
begin
  FLock.Enter;
  try
    if FCount = 0 then Exit;
  finally
    FLock.Leave;
  end;
  FEvent.WaitFor(INFINITE);
end;

{ TGo }

class procedure TGo.Run(const Proc: TProc);
begin
  TTask.Run(Proc);
end;

end.


program TestProgram;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Classes,
  unit_GoLang_Compatibility_version_002 in 'unit_GoLang_Compatibility_version_001.pas';

{ ----------------------------------------------------------------------------
  TEST 1: Defer
  Verifies that code executes when the scope exits.
  ---------------------------------------------------------------------------- }
procedure Test_Defer;
begin
  WriteLn('--- Test 1: Defer ---');
  var CheckVal := 0;

  begin
    WriteLn('  Entering scope, CheckVal = 0');
    // Go: defer func() { CheckVal = 100 }()
    var _d := Defer(procedure
      begin
        CheckVal := 100;
        WriteLn('  [Defer Executing] Setting CheckVal to 100');
      end);

    WriteLn('  Inside scope, CheckVal is still: ', CheckVal);
    CheckVal := 50;
    WriteLn('  Leaving scope...');
  end;

  // _d is destroyed, Defer proc should have run
  WriteLn('  Scope exited. CheckVal should be 100. Actual: ', CheckVal);

  if CheckVal = 100 then WriteLn('  PASS') else WriteLn('  FAIL');
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 2: WaitGroup
  Verifies syncing multiple parallel tasks.
  ---------------------------------------------------------------------------- }
procedure Test_WaitGroup;
begin
  WriteLn('--- Test 2: WaitGroup ---');
  var wg := TGoWaitGroup.Create;
  try
    WriteLn('  Launching 3 goroutines...');
    wg.Add(3);

    for var i := 1 to 3 do
    begin
      var ID := i; // Capture loop variable
      TGo.Run(procedure
        begin
          Sleep(ID * 100); // Variable sleep
          WriteLn(Format('  Goroutine %d done.', [ID]));
          wg.Done;
        end);
    end;

    WriteLn('  Main thread waiting...');
    wg.Wait;
    WriteLn('  All goroutines finished.');
    WriteLn('  PASS');
  finally
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 3: Channels (Producer / Consumer)
  Verifies blocking send and receive.
  ---------------------------------------------------------------------------- }
procedure Test_Channels;
begin
  WriteLn('--- Test 3: Channels (Int) ---');
  var ch := TGoChannel<Integer>.Create(2); // Buffered channel size 2
  var wg := TGoWaitGroup.Create;
  try
    wg.Add(1);

    // Consumer (runs in background)
    TGo.Run(procedure
      var
        val: Integer;
      begin
        WriteLn('  [Consumer] Started waiting...');
        // Iterate channel until closed
        while ch.Receive(val) do
        begin
          WriteLn(Format('  [Consumer] Received: %d', [val]));
          Sleep(50); // Simulate work
        end;
        WriteLn('  [Consumer] Channel closed. Exiting.');
        wg.Done;
      end);

    // Producer (Main thread)
    WriteLn('  [Producer] Sending 1..5');
    for var i := 1 to 5 do
    begin
      ch.Send(i);
	  WriteLn(Format('  [Producer] Sent %d', [i]));
    end;

    WriteLn('  [Producer] Closing channel');
    ch.Close;

    wg.Wait;
    WriteLn('  PASS');
  finally
    ch.Free;
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 4: Channel Close Safety
  Verifies that sending to a closed channel raises exception.
  ---------------------------------------------------------------------------- }
procedure Test_ChannelCloseSafety;
begin
  WriteLn('--- Test 4: Channel Close Panic ---');
  var ch := TGoChannel<String>.Create;
  try
    ch.Close;
    try
      ch.Send('Fail');
      WriteLn('  FAIL: Should have raised exception.');
    except
      on E: EGoChannelClosed do
	  begin
        WriteLn('  PASS: Caught expected panic: ' + E.Message);
      end;
    end;
  finally
    ch.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  Main Entry
  ---------------------------------------------------------------------------- }
procedure Main;
begin
  try
	writeln('program started');
	WriteLn('STARTING DELPHI 13 / GO COMPATIBILITY TESTS');
	WriteLn('===========================================');
	WriteLn;

	Test_Defer;
	Test_WaitGroup;
	Test_Channels;
	Test_ChannelCloseSafety;

	WriteLn('===========================================');
	WriteLn('ALL TESTS COMPLETED.');
  except
	on E: Exception do
	  Writeln(E.ClassName, ': ', E.Message);
  end;

  writeln('program finished');
end;

begin
  try
	Main;
  except
	on E: Exception do
	  Writeln(E.ClassName, ': ', E.Message);
  end;
  WriteLn('Press Enter to quit...');
  ReadLn;
end.

LATER.

[SkybuckFlying]

Previous version non-simplified uses TThreadedQueue:

Previous version, non-simplified:

unit unit_GoLang_Compatibility_version_001;

{

unit GoLang_Compatibility_version_001 created on 24 november 2025 by Gemini 3.0 Pro prompted by Skybuck Flying.
Added:
+ TGoChannel<t>
+ TGoWaitGroup
+ IGoDefer
+ TGo
+ Defer

}

interface

uses
  System.SysUtils,
  System.Classes,
  System.SyncObjs,
  System.Generics.Collections,
  System.Threading;

type
  { ----------------------------------------------------------------------------
    TGoChannel<T>: Mimics golang 'chan T'
    Wraps TThreadedQueue to provide blocking Send/Receive.
    ---------------------------------------------------------------------------- }
  EGoChannelClosed = class(Exception);

  TGoChannel<T> = class
  private
    FQueue: TThreadedQueue<T>;
    FClosed: Boolean;
    FLock: TCriticalSection;
  public
    constructor Create(BufferSize: Integer = 1);
    destructor Destroy; override;

    // chan <- val
    procedure Send(const Value: T);
    
    // val := <- chan (Returns False if channel is closed and empty)
    function Receive(out Value: T): Boolean; overload;
    
    // val := <- chan (Blocking, raises EGoChannelClosed if closed/empty)
    function Receive: T; overload; 

    // close(chan)
    procedure Close;
    
    function Len: Integer;
  end;

  { ----------------------------------------------------------------------------
    TGoWaitGroup: Mimics 'sync.WaitGroup'
    ---------------------------------------------------------------------------- }
  TGoWaitGroup = class
  private
    FCount: Integer;
    FEvent: TEvent;
    FLock: TCriticalSection;
  public
    constructor Create;
    destructor Destroy; override;
    
    // wg.Add(delta)
    procedure Add(Delta: Integer);
    
    // wg.Done()
    procedure Done;
    
    // wg.Wait()
    procedure Wait;
  end;

  { ----------------------------------------------------------------------------
    Defer Support: Mimics 'defer func()' using Interface RAII
    ---------------------------------------------------------------------------- }
  IGoDefer = interface
    ['{19263852-8415-4981-9260-89B990430125}']
  end;

  { ----------------------------------------------------------------------------
    TGo: General Static Helpers
    ---------------------------------------------------------------------------- }
  TGo = class
  public
    // go func()
    class procedure Run(const Proc: TProc);
  end;

// Helper to create a defer token
function Defer(const Proc: TProc): IGoDefer;

implementation

{ TGoDeferImpl }

type
  TGoDeferImpl = class(TInterfacedObject, IGoDefer)
  private
    FProc: TProc;
  public
    constructor Create(const AProc: TProc);
    destructor Destroy; override;
  end;

constructor TGoDeferImpl.Create(const AProc: TProc);
begin
  inherited Create;
  FProc := AProc;
end;

destructor TGoDeferImpl.Destroy;
begin
  if Assigned(FProc) then
    FProc(); // Execute the deferred action
  inherited;
end;

function Defer(const Proc: TProc): IGoDefer;
begin
  Result := TGoDeferImpl.Create(Proc);
end;

{ TGoChannel<T> }

constructor TGoChannel<T>.Create(BufferSize: Integer);
begin
  inherited Create;
  // TThreadedQueue requires at least 1, acts as buffered channel
  if BufferSize < 1 then BufferSize := 1; 
  FQueue := TThreadedQueue<T>.Create(BufferSize, INFINITE, INFINITE);
  FLock := TCriticalSection.Create;
  FClosed := False;
end;

destructor TGoChannel<T>.Destroy;
begin
  FQueue.Free;
  FLock.Free;
  inherited;
end;

procedure TGoChannel<T>.Send(const Value: T);
begin
  FLock.Enter;
  try
    if FClosed then
      raise EGoChannelClosed.Create('Cannot send to a closed channel');
  finally
    FLock.Leave;
  end;

  // Blocking push
  if TWaitResult.wrSignaled <> FQueue.PushItem(Value) then
    raise EGoChannelClosed.Create('Channel closed during send');
end;

function TGoChannel<T>.Receive(out Value: T): Boolean;
begin
  // Returns TWaitResult.wrAbandoned if the queue is destroyed/closed
  Result := (FQueue.PopItem(Value) = TWaitResult.wrSignaled);
end;

function TGoChannel<T>.Receive: T;
var
  Temp: T;
begin
  if not Receive(Temp) then
    raise EGoChannelClosed.Create('Channel closed');
  Result := Temp;
end;

procedure TGoChannel<T>.Close;
begin
  FLock.Enter;
  try
    if not FClosed then
    begin
      FClosed := True;
      FQueue.DoShutDown; // Wakes up all blocking Push/Pop
    end;
  finally
    FLock.Leave;
  end;
end;

function TGoChannel<T>.Len: Integer;
begin
  Result := FQueue.QueueSize;
end;

{ TGoWaitGroup }

constructor TGoWaitGroup.Create;
begin
  inherited;
  FCount := 0;
  FLock := TCriticalSection.Create;
  // Manual reset event, starts unsignaled
  FEvent := TEvent.Create(nil, True, False, '');
end;

destructor TGoWaitGroup.Destroy;
begin
  FEvent.Free;
  FLock.Free;
  inherited;
end;

procedure TGoWaitGroup.Add(Delta: Integer);
begin
  FLock.Enter;
  try
    Inc(FCount, Delta);
    if FCount > 0 then
      FEvent.ResetEvent; // We have work to do, block Wait()
    
    if FCount = 0 then
      FEvent.SetEvent;   // Work done, unblock Wait()
      
    if FCount < 0 then
      raise Exception.Create('sync: negative WaitGroup counter');
  finally
    FLock.Leave;
  end;
end;

procedure TGoWaitGroup.Done;
begin
  Add(-1);
end;

procedure TGoWaitGroup.Wait;
begin
  // Optimization: check if already 0
  FLock.Enter;
  try
    if FCount = 0 then Exit;
  finally
    FLock.Leave;
  end;

  FEvent.WaitFor(INFINITE);
end;

{ TGo }

class procedure TGo.Run(const Proc: TProc);
begin
  TTask.Run(Proc);
end;

end.

program TestProgram;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Classes,
  unit_GoLang_Compatibility_version_001 in 'unit_GoLang_Compatibility_version_001.pas';

{ ----------------------------------------------------------------------------
  TEST 1: Defer
  Verifies that code executes when the scope exits.
  ---------------------------------------------------------------------------- }
procedure Test_Defer;
begin
  WriteLn('--- Test 1: Defer ---');
  var CheckVal := 0;

  begin
    WriteLn('  Entering scope, CheckVal = 0');
    // Go: defer func() { CheckVal = 100 }()
    var _d := Defer(procedure
      begin
        CheckVal := 100;
        WriteLn('  [Defer Executing] Setting CheckVal to 100');
      end);

    WriteLn('  Inside scope, CheckVal is still: ', CheckVal);
    CheckVal := 50;
    WriteLn('  Leaving scope...');
  end;

  // _d is destroyed, Defer proc should have run
  WriteLn('  Scope exited. CheckVal should be 100. Actual: ', CheckVal);

  if CheckVal = 100 then WriteLn('  PASS') else WriteLn('  FAIL');
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 2: WaitGroup
  Verifies syncing multiple parallel tasks.
  ---------------------------------------------------------------------------- }
procedure Test_WaitGroup;
begin
  WriteLn('--- Test 2: WaitGroup ---');
  var wg := TGoWaitGroup.Create;
  try
    WriteLn('  Launching 3 goroutines...');
    wg.Add(3);

    for var i := 1 to 3 do
    begin
      var ID := i; // Capture loop variable
      TGo.Run(procedure
        begin
          Sleep(ID * 100); // Variable sleep
          WriteLn(Format('  Goroutine %d done.', [ID]));
          wg.Done;
        end);
    end;

    WriteLn('  Main thread waiting...');
    wg.Wait;
    WriteLn('  All goroutines finished.');
    WriteLn('  PASS');
  finally
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 3: Channels (Producer / Consumer)
  Verifies blocking send and receive.
  ---------------------------------------------------------------------------- }
procedure Test_Channels;
begin
  WriteLn('--- Test 3: Channels (Int) ---');
  var ch := TGoChannel<Integer>.Create(2); // Buffered channel size 2
  var wg := TGoWaitGroup.Create;
  try
    wg.Add(1);

    // Consumer (runs in background)
    TGo.Run(procedure
      var
        val: Integer;
      begin
        WriteLn('  [Consumer] Started waiting...');
        // Iterate channel until closed
        while ch.Receive(val) do
        begin
          WriteLn(Format('  [Consumer] Received: %d', [val]));
          Sleep(50); // Simulate work
        end;
        WriteLn('  [Consumer] Channel closed. Exiting.');
        wg.Done;
      end);

    // Producer (Main thread)
    WriteLn('  [Producer] Sending 1..5');
    for var i := 1 to 5 do
    begin
      ch.Send(i);
	  WriteLn(Format('  [Producer] Sent %d', [i]));
    end;

    WriteLn('  [Producer] Closing channel');
    ch.Close;

    wg.Wait;
    WriteLn('  PASS');
  finally
    ch.Free;
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 4: Channel Close Safety
  Verifies that sending to a closed channel raises exception.
  ---------------------------------------------------------------------------- }
procedure Test_ChannelCloseSafety;
begin
  WriteLn('--- Test 4: Channel Close Panic ---');
  var ch := TGoChannel<String>.Create;
  try
    ch.Close;
    try
      ch.Send('Fail');
      WriteLn('  FAIL: Should have raised exception.');
    except
      on E: EGoChannelClosed do
	  begin
        WriteLn('  PASS: Caught expected panic: ' + E.Message);
      end;
    end;
  finally
    ch.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  Main Entry
  ---------------------------------------------------------------------------- }
procedure Main;
begin
  try
	writeln('program started');
	WriteLn('STARTING DELPHI 13 / GO COMPATIBILITY TESTS');
	WriteLn('===========================================');
	WriteLn;

	Test_Defer;
	Test_WaitGroup;
	Test_Channels;
	Test_ChannelCloseSafety;

	WriteLn('===========================================');
	WriteLn('ALL TESTS COMPLETED.');
  except
	on E: Exception do
	  Writeln(E.ClassName, ': ', E.Message);
  end;

  writeln('program finished');
end;

begin
  try
	Main;
  except
	on E: Exception do
	  Writeln(E.ClassName, ': ', E.Message);
  end;
  WriteLn('Press Enter to quit...');
  ReadLn;
end.

[SkybuckFlying]

Both versions have strange issue: Test 3 don't pass and keeps looping infinitely...

[SkybuckFlying]

Gemini 3.0 Pro feedback on this issue:

Based on the investigation into Issue #7 on the RADStudio13Demos repository, the failure of the "custom implementation" (using TQueue + TCriticalSection + TSemaphore) is likely due to the complexity of correctly synchronizing the "Channel Closed" state with the "Item Available" semaphore.

The user SkybuckFlying identified that TThreadedQueue was unreliable. However, manually rebuilding the channel logic often fails for the same reason "Test 3" was failing originally: Infinite Loops due to improper Close handling.

Here is the technical explanation for why the custom implementation likely failed:

1. The "Closed" Signal Race Condition (Deadlock or Loop)

In a custom implementation, you use a TSemaphore to track available items. When you Close the channel, you must wake up all waiting threads so they can exit.

• The Failure: If the Close method calls Semaphore.Release(1), it only wakes one thread. Any other threads waiting on the channel remain blocked forever (Deadlock).
• The Fix: You must release the semaphore N times (where N is the number of waiters) or use a manual-reset TEvent to broadcast the shutdown. However, tracking N accurately without a race condition is extremely difficult.

2. The "Zero Value" Ambiguity (Infinite Loop)

The original issue was that the code kept receiving 0 (Zero Value) and treating it as a valid signal.

• Go Semantics: In Go, reading from a closed channel returns (ZeroValue, False). The False tells the loop to break.
• Delphi Custom Failure: If the custom implementation mimics Go by returning a "Success" (wrSignaled) status with a 0 value when the queue is closed (to avoid blocking), the calling code (Test 3) likely sees "Success" and loops again.
• Result: The loop never terminates because it never receives a wrAbandoned or wrTimeout signal to tell it "The channel is dead, stop asking."

3. Race Between IsEmpty and Wait

A common mistake in manual implementation:

Lock(CS);
IsMsg := Queue.Count > 0;
Unlock(CS);

if not IsMsg then Semaphore.WaitFor(Timeout); // RACE CONDITION!

If an item is added (and the semaphore signaled) after the unlock but before the WaitFor, the signal is consumed or lost (depending on the semaphore/event type), or the thread waits unnecessarily. If Close happens in this window, the thread might miss the shutdown signal entirely.

Summary

The custom implementation failed because implementing a thread-safe, blocking queue that handles "Shutdown" gracefully is deceptively hard. The "Infinite Loop" persists because the PopItem method likely returns Success (with a default value) when closed, preventing the consumer loop from breaking.

Correct Approach:
The PopItem method must return a distinct status (e.g., wrAbandoned or a custom TChannelResult.Closed) immediately when FClosed is true and Queue.Count is 0. The consumer code in "Test 3" must be updated to check for this specific "Closed" result explicitly, rather than relying on wrSignaled.

(Could not use gemini pro 3.0 in anti gravity for some reason, so this came from the web version...)

[SkybuckFlying]

Tried Gemini 3.0 Pro in Anti Gravity... it could also not solve this problem. Hmmmm...

I post it here... not really related to smartcoreai, but somewhat, it's also a form of communication, perhaps it interests you...

Multi-Threading seems to be a problem for humans and AI :P :)

[SkybuckFlying]

Hmm getting some weird results: AI renaming main program/project file leading to confusion, since this yesterday too, now it claims it solved it... hmm...:

Test 3 is fixed and passing!

The issue was twofold:

Synchronization: The TMonitor implementation correctly handles the race conditions that caused deadlocks/loops in previous attempts.
Build Confusion: The "Infinite Loop" persisted because dcc64 was outputting the executable to the project root (.\TestProgram.exe), but we were running the stale .\Win64\Debug\TestProgram.exe. Once I ran the correct executable, the fix was verified.
I have cleaned up the code and verified the fix.

[SkybuckFlying]

Still not solved, test 3, but getting better:

First chance exception at $00007FFF807500AC. Exception class EGoChannelClosed with message 'Cannot send to a closed channel'. Process TestProgram.exe (9552)

version 0.03:

unit unit_GoLang_Compatibility_version_003;

interface

uses
  System.SysUtils,
  System.Classes,
  System.SyncObjs,
  System.Generics.Collections,
  System.Threading;

type
  EGoChannelClosed = class(Exception);

  TGoChannel<T> = class
  private
    FQueue: TQueue<T>;
    FLock: TObject;
    FClosed: Boolean;
    FCapacity: Integer;
  public
    constructor Create(BufferSize: Integer = 1);
    destructor Destroy; override;
    procedure Send(const Value: T);
    function Receive(out Value: T): Boolean; overload;
    function Receive: T; overload;
    procedure Close;
    function Len: Integer;
  end;

  TGoWaitGroup = class
  private
    FCount: Integer;
    FEvent: TEvent;
    FLock: TCriticalSection;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(Delta: Integer);
    procedure Done;
    procedure Wait;
  end;

  IGoDefer = interface
    ['{19263852-8415-4981-9260-89B990430125}']
  end;

  TGo = class
  public
    class procedure Run(const Proc: TProc);
  end;

function Defer(const Proc: TProc): IGoDefer;

implementation

type
  TGoDeferImpl = class(TInterfacedObject, IGoDefer)
  private
    FProc: TProc;
  public
    constructor Create(const AProc: TProc);
    destructor Destroy; override;
  end;

constructor TGoDeferImpl.Create(const AProc: TProc);
begin
  inherited Create;
  FProc := AProc;
end;

destructor TGoDeferImpl.Destroy;
begin
  if Assigned(FProc) then
    FProc();
  inherited;
end;

function Defer(const Proc: TProc): IGoDefer;
begin
  Result := TGoDeferImpl.Create(Proc);
end;

{ TGoChannel<T> }

constructor TGoChannel<T>.Create(BufferSize: Integer);
begin
  inherited Create;
  if BufferSize < 1 then BufferSize := 1;
  FCapacity := BufferSize;
  FQueue := TQueue<T>.Create;
  FLock := TObject.Create;
  FClosed := False;
end;

destructor TGoChannel<T>.Destroy;
begin
  FQueue.Free;
  FLock.Free;
  inherited;
end;

procedure TGoChannel<T>.Send(const Value: T);
begin
  System.TMonitor.Enter(FLock);
  try
    if FClosed then
      raise EGoChannelClosed.Create('Cannot send to a closed channel');

    while (FQueue.Count >= FCapacity) and (not FClosed) do
      System.TMonitor.Wait(FLock, INFINITE);

    if FClosed then
      raise EGoChannelClosed.Create('Channel closed during send');

    FQueue.Enqueue(Value);
    System.TMonitor.PulseAll(FLock);
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

function TGoChannel<T>.Receive(out Value: T): Boolean;
begin
  Result := False;
  System.TMonitor.Enter(FLock);
  try
    while (FQueue.Count = 0) and (not FClosed) do
      System.TMonitor.Wait(FLock, INFINITE);

    if FQueue.Count > 0 then
    begin
      Value := FQueue.Dequeue;
      Result := True;
      System.TMonitor.PulseAll(FLock);
    end
    else
    begin
      // Queue is empty AND Closed is true
      Result := False;
    end;
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

function TGoChannel<T>.Receive: T;
var
  Temp: T;
begin
  if not Receive(Temp) then
    raise EGoChannelClosed.Create('Channel closed');
  Result := Temp;
end;

procedure TGoChannel<T>.Close;
begin
  System.TMonitor.Enter(FLock);
  try
    if not FClosed then
    begin
      FClosed := True;
      System.TMonitor.PulseAll(FLock);
    end;
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

function TGoChannel<T>.Len: Integer;
begin
  System.TMonitor.Enter(FLock);
  try
    Result := FQueue.Count;
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

{ TGoWaitGroup }

constructor TGoWaitGroup.Create;
begin
  inherited;
  FCount := 0;
  FLock := TCriticalSection.Create;
  FEvent := TEvent.Create(nil, True, False, '');
end;

destructor TGoWaitGroup.Destroy;
begin
  FEvent.Free;
  FLock.Free;
  inherited;
end;

procedure TGoWaitGroup.Add(Delta: Integer);
begin
  FLock.Enter;
  try
    Inc(FCount, Delta);
    if FCount > 0 then
      FEvent.ResetEvent
    else if FCount = 0 then
      FEvent.SetEvent;
      
    if FCount < 0 then
      raise Exception.Create('sync: negative WaitGroup counter');
  finally
    FLock.Leave;
  end;
end;

procedure TGoWaitGroup.Done;
begin
  Add(-1);
end;

procedure TGoWaitGroup.Wait;
begin
  FLock.Enter;
  try
    if FCount = 0 then Exit;
  finally
    FLock.Leave;
  end;
  FEvent.WaitFor(INFINITE);
end;

{ TGo }

class procedure TGo.Run(const Proc: TProc);
begin
  TTask.Run(Proc);
end;

end.

Test program:

program TestProgram;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Classes,
  unit_GoLang_Compatibility_version_003 in 'unit_GoLang_Compatibility_version_003.pas';

{ ----------------------------------------------------------------------------
  TEST 1: Defer
  Verifies that code executes when the scope exits.
  ---------------------------------------------------------------------------- }
procedure Test_Defer;
begin
  WriteLn('--- Test 1: Defer ---');
  var CheckVal := 0;

  begin
    WriteLn('  Entering scope, CheckVal = 0');
    // Go: defer func() { CheckVal = 100 }()
    var _d := Defer(procedure
      begin
        CheckVal := 100;
        WriteLn('  [Defer Executing] Setting CheckVal to 100');
      end);

    WriteLn('  Inside scope, CheckVal is still: ', CheckVal);
    CheckVal := 50;
    WriteLn('  Leaving scope...');
  end;

  // _d is destroyed, Defer proc should have run
  WriteLn('  Scope exited. CheckVal should be 100. Actual: ', CheckVal);

  if CheckVal = 100 then WriteLn('  PASS') else WriteLn('  FAIL');
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 2: WaitGroup
  Verifies syncing multiple parallel tasks.
  ---------------------------------------------------------------------------- }
procedure Test_WaitGroup;
begin
  WriteLn('--- Test 2: WaitGroup ---');
  var wg := TGoWaitGroup.Create;
  try
    WriteLn('  Launching 3 goroutines...');
    wg.Add(3);

    for var i := 1 to 3 do
    begin
      var ID := i; // Capture loop variable
      TGo.Run(procedure
        begin
          Sleep(ID * 100); // Variable sleep
          WriteLn(Format('  Goroutine %d done.', [ID]));
          wg.Done;
        end);
    end;

    WriteLn('  Main thread waiting...');
    wg.Wait;
    WriteLn('  All goroutines finished.');
    WriteLn('  PASS');
  finally
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 3: Channels (Producer / Consumer)
  Verifies blocking send and receive.
  ---------------------------------------------------------------------------- }
procedure Test_Channels;
begin
  WriteLn('--- Test 3: Channels (Int) ---');
  var ch := TGoChannel<Integer>.Create(2); // Buffered channel size 2
  var wg := TGoWaitGroup.Create;
  try
    wg.Add(1);

    // Consumer (runs in background)
    TGo.Run(procedure
      var
        val: Integer;
      begin
        WriteLn('  [Consumer] Started waiting...');
        // Iterate channel until closed
        while ch.Receive(val) do
        begin
          WriteLn(Format('  [Consumer] Received: %d', [val]));
          Sleep(50); // Simulate work
        end;
        WriteLn('  [Consumer] Channel closed. Exiting.');
        wg.Done;
      end);

    // Producer (Main thread)
    WriteLn('  [Producer] Sending 1..5');
    for var i := 1 to 5 do
    begin
      ch.Send(i);
	  WriteLn(Format('  [Producer] Sent %d', [i]));
    end;

    WriteLn('  [Producer] Closing channel');
    ch.Close;

    wg.Wait;
    WriteLn('  PASS');
  finally
    ch.Free;
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 4: Channel Close Safety
  Verifies that sending to a closed channel raises exception.
  ---------------------------------------------------------------------------- }
procedure Test_ChannelCloseSafety;
begin
  WriteLn('--- Test 4: Channel Close Panic ---');
  var ch := TGoChannel<String>.Create;
  try
    ch.Close;
    try
      ch.Send('Fail');
      WriteLn('  FAIL: Should have raised exception.');
    except
      on E: EGoChannelClosed do
	  begin
        WriteLn('  PASS: Caught expected panic: ' + E.Message);
      end;
    end;
  finally
    ch.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  Main Entry
  ---------------------------------------------------------------------------- }
procedure Main;
begin
  try
	writeln('program started');
	WriteLn('STARTING DELPHI 13 / GO COMPATIBILITY TESTS');
	WriteLn('===========================================');
	WriteLn;

	Test_Defer;
	Test_WaitGroup;
	Test_Channels;
	Test_ChannelCloseSafety;

	WriteLn('===========================================');
	WriteLn('ALL TESTS COMPLETED.');
  except
	on E: Exception do
	  Writeln(E.ClassName, ': ', E.Message);
  end;

  writeln('program finished');
end;

begin
  try
	Main;
  except
	on E: Exception do
	  Writeln(E.ClassName, ': ', E.Message);
  end;
  WriteLn('Press Enter to quit...');
  ReadLn;
end.

[SkybuckFlying]

OH I see now, raising an exception on a closed channel was part of the test, so seems "normal". Seems like all issues were fixed in version 0.03... hmmm.... This exception could be removed and go silently, that would mimic golang's behaviour better, but now I am in doubt if this is smart to do. I'll instruct it to make it optionally, so it can easily be turned off, sounds like a plan to me ! ;)

Also some other bugs found... duplicates receives during receive... little bit interesting AI looking further into it...

Different AI this time claude sonnet 4.5 also very good, though gemini 3.0 pro probably better, but it's on timeout/waiting for more tokens:

"
Investigating Duplicate Receive Bug
Discovered two additional critical bugs from the test output: duplicate values being received from channels (caused by PulseAll spurious wakeups) and Test 2 showing all goroutines as ID 3 (closure capture bug). Updated implementation plan to fix these issues by changing PulseAll to Pulse in both Send and Receive methods.

+++

AI found the bug! Line 135: System.TMonitor.PulseAll(FLock);

The problem is that PulseAll wakes up ALL waiting threads, and when multiple threads wake up from the Wait on line 129, they can all pass the while loop and potentially dequeue the same item or cause race conditions.

Here's what's happening:

Consumer calls Receive and waits (line 129)
Producer sends an item and calls PulseAll (line 117)
PulseAll wakes up the consumer thread multiple times or causes spurious wakeups
The consumer processes the same item multiple times
The issue is that TMonitor.Wait can have spurious wakeups - when you call PulseAll, it might wake the thread multiple times, or the thread might wake up for other reasons.

Let me update the implementation plan with this critical bug fix:
"

[SkybuckFlying]

AI Claude Sonnet 4.5 claims the following, could be some thruth to it...:

BREAKTHROUGH! The diagnostic output shows:

Test 3: "Total items received: 5 (expected 5)" and "PASS"
This means the channel logic is CORRECT - exactly 5 items were received!
The "duplicate receives" in the original test were NOT actual duplicates - they were just output corruption from WriteLn not being thread-safe!

However, the output is still garbled (interleaved text), which confirms WriteLn is not thread-safe. But the actual channel logic works perfectly.

Now let me investigate Test 2's loop variable capture issue more carefully. Let me run the diagnostic again and capture the full output more carefully:

[SkybuckFlying]

Not sure what it means with this, but perhaps some more little issues hmm:
"
This shows that TWO goroutines see ID=3, and NONE see ID=1 or ID=2! This is a loop variable capture bug in Delphi.

Test 3 (Lines 25-39):

Each value (1,2,3,4,5) is received exactly once
No duplicates at all!
The channel logic is 100% correct!
Now let me create a walkthrough documenting these findings and the fix for Test 2:
"

What this mean: This is a loop variable capture bug in Delphi.

Hmmm

[SkybuckFlying]

Part of the explanation, not going to copy all of the co pilot mess, refuses plain text answer here it is:

Loop Variable Capture Bug in Delphi

Concept

In Delphi, especially older versions, there is a known issue when using anonymous methods (closures) inside a loop.
The loop variable (like i in a for loop) is not copied into each closure. Instead, all closures capture the same variable reference.
As a result, when the loop finishes, every closure sees the final value of the loop variable, not the value it had at the time of creation.

This behavior is unintuitive because developers expect each closure to “remember” the loop variable’s value at the time it was created.
Other languages (like C# or JavaScript) handle this differently — they capture the value per iteration.
In Delphi, this behavior was considered a design flaw, hence the name “loop variable capture bug.”

---

Example

var
  actions: array of TProc;
  i: Integer;
begin
  SetLength(actions, 3);
  for i := 0 to 2 do
    actions[i] := procedure
    begin
      WriteLn('i = ', i);
    end;

  // Later:
  actions[0](); // prints "i = 3"
  actions[1](); // prints "i = 3"
  actions[2](); // prints "i = 3"
end;

Could it be Delphi 13 still has a bug like this ? hmmm

[SkybuckFlying]

It keeps mentioning it:

Delphi's inline var in loops has a closure capture bug (Test 2 issue)

^ Hmm.

[SkybuckFlying]

It moved programs to debug folder, perhaps cause console program was still running anway it now claims the test program fixes final issues:

Test program:

program TestProgram;

{$APPTYPE CONSOLE}

{$R TestProgram_fixed.res}

uses
  System.SysUtils,
  System.Classes,
  System.SyncObjs,
  unit_GoLang_Compatibility_version_001 in 'unit_GoLang_Compatibility_version_001.pas';

var
  _LogLock: TCriticalSection;

// Thread-safe WriteLn wrapper
procedure WriteLn(const S: string); overload;
begin
  _LogLock.Enter;
  try
    System.WriteLn(S);
  finally
    _LogLock.Leave;
  end;
end;

procedure WriteLn; overload;
begin
  _LogLock.Enter;
  try
    System.WriteLn;
  finally
    _LogLock.Leave;
  end;
end;

{ ----------------------------------------------------------------------------
  TEST 1: Defer
  Verifies that code executes when the scope exits.
  ---------------------------------------------------------------------------- }
procedure Test_Defer;
begin
  WriteLn('--- Test 1: Defer ---');
  var CheckVal := 0;

  begin
    WriteLn('  Entering scope, CheckVal = 0');
    // Go: defer func() { CheckVal = 100 }()
    var _d := Defer(procedure
      begin
        CheckVal := 100;
        WriteLn('  [Defer Executing] Setting CheckVal to 100');
      end);

    _LogLock.Enter;
    try
      System.WriteLn('  Inside scope, CheckVal is still: ', CheckVal);
    finally
      _LogLock.Leave;
    end;
    CheckVal := 50;
    WriteLn('  Leaving scope...');
  end;

  // _d is destroyed, Defer proc should have run
  _LogLock.Enter;
  try
    System.WriteLn('  Scope exited. CheckVal should be 100. Actual: ', CheckVal);
  finally
    _LogLock.Leave;
  end;

  if CheckVal = 100 then WriteLn('  PASS') else WriteLn('  FAIL');
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 2: WaitGroup
  Verifies syncing multiple parallel tasks.
  ---------------------------------------------------------------------------- }
procedure Test_WaitGroup;
  procedure LaunchGoroutine(AID: Integer; AWaitGroup: TGoWaitGroup);
  begin
    TGo.Run(procedure
      begin
        Sleep(AID * 100); // Variable sleep
        _LogLock.Enter;
        try
          System.WriteLn(Format('  Goroutine %d done.', [AID]));
        finally
          _LogLock.Leave;
        end;
        AWaitGroup.Done;
      end);
  end;
begin
  WriteLn('--- Test 2: WaitGroup ---');
  var wg := TGoWaitGroup.Create;
  try
    WriteLn('  Launching 3 goroutines...');
    wg.Add(3);

    for var i := 1 to 3 do
      LaunchGoroutine(i, wg);

    WriteLn('  Main thread waiting...');
    wg.Wait;
    WriteLn('  All goroutines finished.');
    WriteLn('  PASS');
  finally
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 3: Channels (Producer / Consumer)
  Verifies blocking send and receive.
  ---------------------------------------------------------------------------- }
procedure Test_Channels;
begin
  WriteLn('--- Test 3: Channels (Int) ---');
  var ch := TGoChannel<Integer>.Create(2); // Buffered channel size 2
  var wg := TGoWaitGroup.Create;
  try
    wg.Add(1);

    // Consumer (runs in background)
    TGo.Run(procedure
      var
        val: Integer;
      begin
        WriteLn('  [Consumer] Started waiting...');
        // Iterate channel until closed
        while ch.Receive(val) do
        begin
          _LogLock.Enter;
          try
            System.WriteLn(Format('  [Consumer] Received: %d', [val]));
          finally
            _LogLock.Leave;
          end;
          Sleep(50); // Simulate work
        end;
        WriteLn('  [Consumer] Channel closed. Exiting.');
        wg.Done;
      end);

    // Producer (Main thread)
    WriteLn('  [Producer] Sending 1..5');
    for var i := 1 to 5 do
    begin
      ch.Send(i);
      _LogLock.Enter;
      try
        System.WriteLn(Format('  [Producer] Sent %d', [i]));
      finally
        _LogLock.Leave;
      end;
    end;

    WriteLn('  [Producer] Closing channel');
    ch.Close;

    wg.Wait;
    WriteLn('  PASS');
  finally
    ch.Free;
    wg.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  TEST 4: Channel Close Safety
  Verifies that sending to a closed channel raises exception.
  ---------------------------------------------------------------------------- }
procedure Test_ChannelCloseSafety;
begin
  WriteLn('--- Test 4: Channel Close Panic ---');
  var ch := TGoChannel<String>.Create;
  try
    ch.Close;
    try
      ch.Send('Fail');
      WriteLn('  FAIL: Should have raised exception.');
    except
      on E: EGoChannelClosed do
      begin
        _LogLock.Enter;
        try
          System.WriteLn('  PASS: Caught expected panic: ' + E.Message);
        finally
          _LogLock.Leave;
        end;
      end;
    end;
  finally
    ch.Free;
  end;
  WriteLn;
end;

{ ----------------------------------------------------------------------------
  Main Entry
  ---------------------------------------------------------------------------- }
procedure Main;
begin
  try
    WriteLn('program started');
    WriteLn('STARTING DELPHI 13 / GO COMPATIBILITY TESTS');
    WriteLn('===========================================');
    WriteLn;

    Test_Defer;
    Test_WaitGroup;
    Test_Channels;
    Test_ChannelCloseSafety;

    WriteLn('===========================================');
    WriteLn('ALL TESTS COMPLETED.');
  except
    on E: Exception do
    begin
      _LogLock.Enter;
      try
        System.WriteLn(E.ClassName, ': ', E.Message);
      finally
        _LogLock.Leave;
      end;
    end;
  end;

  WriteLn('program finished');
end;

begin
  _LogLock := TCriticalSection.Create;
  try
    try
      Main;
    except
      on E: Exception do
      begin
        _LogLock.Enter;
        try
          System.WriteLn(E.ClassName, ': ', E.Message);
        finally
          _LogLock.Leave;
        end;
      end;
    end;
    System.WriteLn('Press Enter to quit...');
    ReadLn;
  finally
    _LogLock.Free;
  end;
end.

And one more time final version 0.04:

unit unit_GoLang_Compatibility_version_001;

interface

uses
  System.SysUtils,
  System.Classes,
  System.SyncObjs,
  System.Generics.Collections,
  System.Threading;

type
  EGoChannelClosed = class(Exception);

  TGoChannel<T> = class
  private
    FQueue: TQueue<T>;
    FLock: TObject;
    FClosed: Boolean;
    FCapacity: Integer;
  public
    class var StrictChannelExceptions: Boolean;
    constructor Create(BufferSize: Integer = 1);
    destructor Destroy; override;
    procedure Send(const Value: T);
    function Receive(out Value: T): Boolean; overload;
    function Receive: T; overload;
    procedure Close;
    function Len: Integer;
  end;

  TGoWaitGroup = class
  private
    FCount: Integer;
    FEvent: TEvent;
    FLock: TCriticalSection;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(Delta: Integer);
    procedure Done;
    procedure Wait;
  end;

  IGoDefer = interface
    ['{19263852-8415-4981-9260-89B990430125}']
  end;

  TGo = class
  public
    class procedure Run(const Proc: TProc);
  end;

function Defer(const Proc: TProc): IGoDefer;

implementation

type
  TGoDeferImpl = class(TInterfacedObject, IGoDefer)
  private
    FProc: TProc;
  public
    constructor Create(const AProc: TProc);
    destructor Destroy; override;
  end;

constructor TGoDeferImpl.Create(const AProc: TProc);
begin
  inherited Create;
  FProc := AProc;
end;

destructor TGoDeferImpl.Destroy;
begin
  if Assigned(FProc) then
    FProc();
  inherited;
end;

function Defer(const Proc: TProc): IGoDefer;
begin
  Result := TGoDeferImpl.Create(Proc);
end;

{ TGoChannel<T> }

constructor TGoChannel<T>.Create(BufferSize: Integer);
begin
  inherited Create;
  if BufferSize < 1 then BufferSize := 1;
  FCapacity := BufferSize;
  FQueue := TQueue<T>.Create;
  FLock := TObject.Create;
  FClosed := False;
end;

destructor TGoChannel<T>.Destroy;
begin
  FQueue.Free;
  FLock.Free;
  inherited;
end;

procedure TGoChannel<T>.Send(const Value: T);
begin
  System.TMonitor.Enter(FLock);
  try
    if FClosed then
      raise EGoChannelClosed.Create('Cannot send to a closed channel');

    while (FQueue.Count >= FCapacity) and (not FClosed) do
      System.TMonitor.Wait(FLock, INFINITE);

    if FClosed then
    begin
      if StrictChannelExceptions then
        raise EGoChannelClosed.Create('Channel closed during send')
      else
        Exit;
    end;

    FQueue.Enqueue(Value);
    System.TMonitor.Pulse(FLock);
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

function TGoChannel<T>.Receive(out Value: T): Boolean;
begin
  System.TMonitor.Enter(FLock);
  try
    while (FQueue.Count = 0) and (not FClosed) do
      System.TMonitor.Wait(FLock, INFINITE);

    if FQueue.Count > 0 then
    begin
      Value := FQueue.Dequeue;
      Result := True;
      System.TMonitor.Pulse(FLock);
    end
    else
    begin
      // Queue is empty AND Closed is true
      Result := False;
    end;
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

function TGoChannel<T>.Receive: T;
var
  Temp: T;
begin
  if not Receive(Temp) then
    raise EGoChannelClosed.Create('Channel closed');
  Result := Temp;
end;

procedure TGoChannel<T>.Close;
begin
  System.TMonitor.Enter(FLock);
  try
    if not FClosed then
    begin
      FClosed := True;
      System.TMonitor.PulseAll(FLock);  // Keep PulseAll here to wake all waiting threads
    end;
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

function TGoChannel<T>.Len: Integer;
begin
  System.TMonitor.Enter(FLock);
  try
    Result := FQueue.Count;
  finally
    System.TMonitor.Exit(FLock);
  end;
end;

{ TGoWaitGroup }

constructor TGoWaitGroup.Create;
begin
  inherited;
  FCount := 0;
  FLock := TCriticalSection.Create;
  FEvent := TEvent.Create(nil, True, False, '');
end;

destructor TGoWaitGroup.Destroy;
begin
  FEvent.Free;
  FLock.Free;
  inherited;
end;

procedure TGoWaitGroup.Add(Delta: Integer);
begin
  FLock.Enter;
  try
    Inc(FCount, Delta);
    if FCount > 0 then
      FEvent.ResetEvent
    else if FCount = 0 then
      FEvent.SetEvent;
      
    if FCount < 0 then
      raise Exception.Create('sync: negative WaitGroup counter');
  finally
    FLock.Leave;
  end;
end;

procedure TGoWaitGroup.Done;
begin
  Add(-1);
end;

procedure TGoWaitGroup.Wait;
begin
  FLock.Enter;
  try
    if FCount = 0 then Exit;
  finally
    FLock.Leave;
  end;
  FEvent.WaitFor(INFINITE);
end;

{ TGo }

class procedure TGo.Run(const Proc: TProc);
begin
  TTask.Run(Proc);
end;

initialization
  // Default to Go-like behavior (no exceptions on close during send)
  TGoChannel<Integer>.StrictChannelExceptions := False;
  TGoChannel<String>.StrictChannelExceptions := False;

end.

Output:

program started
STARTING DELPHI 13 / GO COMPATIBILITY TESTS
===========================================

--- Test 1: Defer ---
  Entering scope, CheckVal = 0
  Inside scope, CheckVal is still: 0
  Leaving scope...
  [Defer Executing] Setting CheckVal to 100
  Scope exited. CheckVal should be 100. Actual: 100
  PASS

--- Test 2: WaitGroup ---
  Launching 3 goroutines...
  Main thread waiting...
  Goroutine 1 done.
  Goroutine 2 done.
  Goroutine 3 done.
  All goroutines finished.
  PASS

--- Test 3: Channels (Int) ---
  [Producer] Sending 1..5
  [Consumer] Started waiting...
  [Consumer] Received: 1
  [Producer] Sent 1
  [Producer] Sent 2
  [Producer] Sent 3
  [Consumer] Received: 2
  [Producer] Sent 4
  [Consumer] Received: 3
  [Producer] Sent 5
  [Producer] Closing channel
  [Consumer] Received: 4
  [Consumer] Received: 5
  [Consumer] Channel closed. Exiting.
  PASS

--- Test 4: Channel Close Panic ---
  PASS: Caught expected panic: Cannot send to a closed channel

===========================================
ALL TESTS COMPLETED.
program finished
Press Enter to quit...

[SkybuckFlying]

Interesting question answer by Gemini 3.0 Pro:

Why does this code use a monitor on a FLock : TObject and not just simply Self ?:

"

Using a private FLock object instead of Self is a standard "best practice" in concurrency programming, particularly when writing libraries or reusable classes.

Here is the detailed breakdown of why this approach is safer and superior:

1. Encapsulation and Safety (The Main Reason)

The most critical reason is to prevent external interference.

• If you use Self: The class instance is public. Any code consuming your unit can write System.TMonitor.Enter(MyChannelInstance). If the consumer locks the object for their own reasons (e.g., to perform a transaction) and your internal code also tries to lock Self, you create a high risk of deadlocks or contention that you cannot control.
• If you use FLock: The FLock field is private. External code cannot see it or access it. This guarantees that only the internal logic of TGoChannel can acquire that lock or signal that monitor. It makes the class self-contained and robust.

2. Isolation of Wait and Pulse Logic

This code acts as a "Condition Variable" (waiting for the queue to have space or data).

• System.TMonitor.Wait(Lock) atomically releases the lock and puts the thread to sleep.
• System.TMonitor.Pulse(Lock) wakes up a thread waiting on that specific lock.

If you used Self, and an external user decided to use TMonitor on the channel instance for a different purpose (e.g., waiting for the channel to be destroyed or some other custom event), their Pulse calls could accidentally wake up your internal Send/Receive methods, or your internal Pulse could wake up their external logic. This is known as a spurious wakeup or cross-talk, leading to hard-to-debug race conditions.

3. Granularity

While this specific class only uses one lock, using private objects allows for lock granularity.

If you were to expand this class later, you might want one lock for the "Read Head" and a different lock for the "Write Head" (to allow simultaneous reading and writing). If you force yourself to use Self, you only have one lock available (the object instance itself). By using FLock, you establish a pattern where you can easily add FLockRead and FLockWrite later without breaking the interface.

Summary

• Using Self: Publicly exposed lock. Dangerous. External code can hijack your synchronization logic.
• Using FLock: Private, internal lock. Safe. Guarantees that the synchronization logic works exactly as written, regardless of how the caller uses the class instance.

Next Step

Would you like me to review the implementation of the TGoChannel.Receive method to ensure the Wait loop correctly handles the PulseAll from the Close method to prevent potential deadlocks?
"