unit Myc.Lazy;

interface

uses
    System.SysUtils,
    Myc.Signals;

type
    IMycLazy<T> = interface
        {$REGION 'property access'}
        function GetChanged: IMycState;
        {$ENDREGION}
        function Pop( out Res: T ): Boolean;
        property Changed: IMycState read GetChanged;
    end;

    TLazy<T> = record
    private
        FLazy: IMycLazy<T>;
        function GetChanged: IMycState; inline;
    class var
        FNull: IMycLazy<T>;
        class constructor CreateClass;

    public
        constructor Create(const ALazy: IMycLazy<T>);

        class function Construct( const Changing: IMycState; const Proc: TFunc<T> ): IMycLazy<T>; static;

        class operator Implicit(const A: IMycLazy<T>): TLazy<T>; overload;
        class operator Implicit(const A: TLazy<T>): IMycLazy<T>; overload;

        function Pop(out Res: T): Boolean; inline;

        property Changed: IMycState read GetChanged;
    end;

implementation

uses
    Myc.Core.Lazy;

constructor TLazy<T>.Create(const ALazy: IMycLazy<T>);
begin
    FLazy := ALazy;
    if not Assigned(FLazy) then
        FLazy := FNull;
end;

class function TLazy<T>.Construct(const Changing: IMycState; const Proc: TFunc<T>): IMycLazy<T>;
begin
    Result := TMycFuncLazy<T>.Create( Changing, Proc );
end;

class constructor TLazy<T>.CreateClass;
begin
    FNull := TMycNullLazy<T>.Create;
end;

function TLazy<T>.GetChanged: IMycState;
begin
    Result := FLazy.Changed;
end;

function TLazy<T>.Pop(out Res: T): Boolean;
begin
    Result := FLazy.Pop( Res );
end;

class operator TLazy<T>.Implicit(const A: IMycLazy<T>): TLazy<T>;
begin
    Result.Create( A );
end;

class operator TLazy<T>.Implicit(const A: TLazy<T>): IMycLazy<T>;
begin
    Result := A.FLazy;
end;

end.