unit Myc.Lazy;

interface

uses
    System.SysUtils,
    Myc.Signals;

type
    TMutable<T> = record
        type
            IMutable = interface
                {$REGION 'property access'}
                function GetChanged: TSignal;
                function GetValue: T;
                {$ENDREGION}
                property Changed: TSignal read GetChanged;
                property Value: T read GetValue;
            end;

            IWriteableMutable = interface(IMutable)
                procedure SetValue(const Value: T);
            end;

    {$REGION 'private'}
    strict private
        class var
            FNull: IMutable;
        class constructor CreateClass;

    private
        FMutable: IMutable;
        function GetChanged: TSignal; inline;
    {$ENDREGION}
    public
        constructor Create(const AMutable: IMutable);
        class operator Initialize(out Dest: TMutable<T>);
        class operator Implicit(const A: IMutable): TMutable<T>; overload;
        class operator Implicit(const A: TMutable<T>): IMutable; overload;

        class property Null: IMutable read FNull;

        class function Construct(const Changing: TSignal; const Proc: TFunc<T>): TMutable<T>; overload; static;

        class function CreateWriteable(const Init: T): IWriteableMutable; overload; static;

        property Changed: TSignal read GetChanged;
    end;

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

    {$REGION 'private'}
    strict private
        class var
            FNull: ILazy;
        class constructor CreateClass;

    private
        FLazy: ILazy;
        function GetChanged: TState; inline;
    {$ENDREGION}
    public
        constructor Create(const ALazy: ILazy);
        class operator Initialize(out Dest: TLazy<T>);
        class operator Implicit(const A: ILazy): TLazy<T>; overload;
        class operator Implicit(const A: TLazy<T>): ILazy; overload;

        class function Construct(const Changing: TState; const Proc: TFunc<T>): TLazy<T>; overload; static;
        class function Construct(const Value: ILazy): TLazy<T>; overload; static;

        class property Null: ILazy read FNull;

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

        property Changed: TState read GetChanged;
    end;

implementation

uses
    Myc.Core.Lazy;

{ TMutable<T> }

constructor TMutable<T>.Create(const AMutable: IMutable);
begin
    FMutable := AMutable;
    if not Assigned(FMutable) then
        FMutable := FNull;
end;

class constructor TMutable<T>.CreateClass;
begin
    FNull := TMycNullMutable<T>.Create;
end;

class function TMutable<T>.Construct(const Changing: TSignal; const Proc: TFunc<T>): TMutable<T>;
begin
    Result := TMycFuncMutable<T>.Create(Changing, Proc);
end;

class function TMutable<T>.CreateWriteable(const Init: T): IWriteableMutable;
begin
    Result := TMycWriteableMutable<T>.Create(Init);
end;

function TMutable<T>.GetChanged: TSignal;
begin
    Result := FMutable.Changed;
end;

class operator TMutable<T>.Implicit(const A: TMutable<T>): IMutable;
begin
    Result := A.FMutable;
end;

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

class operator TMutable<T>.Initialize(out Dest: TMutable<T>);
begin
    Dest.FMutable := FNull;
end;

{ TLazy<T> }

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

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

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

class function TLazy<T>.Construct(const Value: ILazy): TLazy<T>;
begin
    Result := TMycChainedLazy<T>.Create(Value);
end;

function TLazy<T>.GetChanged: TState;
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: ILazy): TLazy<T>;
begin
    Result.Create(A);
end;

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

class operator TLazy<T>.Initialize(out Dest: TLazy<T>);
begin
    Dest.FLazy := FNull;
end;

end.