current memo and lazy impl

Lab6/cs2030s/fp/Lazy.java

@@ -1,5 +1,41 @@
 package cs2030s.fp;
 
-public class Lazy<T> /* implements Immutatorable<T> */ {
+public class Lazy<T> implements Immutatorable<T> {
   private Constant<? extends T> init;
-}
+
+  protected Lazy(Constant<? extends T> c) {
+    this.init = c;
+  }
+
+  public T get() {
+    return init.init();
+  }
+
+  public static <T> Lazy<T> from(T v) {
+    return new Lazy<>(() -> v);
+  }
+
+  public static <T> Lazy<T> from(Constant<? extends T> v) {
+    return new Lazy<T>(v);
+  }
+
+  @Override
+  public <R> Lazy<R> transform(Immutator<? extends R, ? super T> f) {
+    return Lazy.from(() -> f.invoke(this.init.init()));
+  }
+
+  public <R> Lazy<R> next(Immutator<? extends Lazy<? extends R>, ? super T> f) {
+
+    @SuppressWarnings("unchecked")
+    Lazy<R> result = (Lazy<R>) Lazy.from(() -> f.invoke(this.init.init()));
+
+    return result;
+
+  }
+
+  @Override
+  public String toString() {
+    return this.init.init().toString();
+  }
+
+}

Lab6/cs2030s/fp/Memo.java

@@ -2,4 +2,43 @@ package cs2030s.fp;
 
 public class Memo<T> extends Lazy<T> {
   private Actually<T> value;
+
+  protected Memo(Constant<? extends T> c) {
+    super(c);
+    // if actually is err, it is uninitialised
+    this.value = Actually.<T>err(null);
+  }
+
+  protected Memo(T v) {
+    super(() -> v);
+    this.value = Actually.ok(v);
+  }
+
+  public static <T> Memo<T> from(T v) {
+    return new Memo<T>(v);
+  }
+
+  public static <T> Memo<T> from(Constant<? extends T> v) {
+    return new Memo<T>(v);
+  }
+
+  public T get() {
+    T result = this.value.except(() -> super.get());
+    this.value = Actually.ok(result);
+    return result;
+  }
+
+  @Override
+  public <R> Memo<R> transform(Immutator<? extends R, ? super T> f) {
+    return Memo.<R>from(() -> f.invoke(this.get()));
+  }
+
+  public <R> Memo<R> next(Immutator<? extends Lazy<? extends R>, ? super T> f) {
+    return Memo.<R>from(() -> f.invoke(this.get()).get());
+  }
+
+  @Override
+  public String toString() {
+    return this.value.next(t -> Actually.ok(String.valueOf(t))).unless("?");
+  }
 }