Implemented TLazy + Tests

Src/Myc.Lazy.pas

@@ -0,0 +1,81 @@
+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.