Changed memo() to use strong references. Added weakMemo() and softMemo().

orionll · orionll · commit 05f7dbf017b4 · 2015-06-09T15:46:02.000+06:00
diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
@@ -37,6 +37,8 @@ public static <A> P1<A> p(final A a) {
         return a;
       }
       @Override public P1<A> memo() { return this; }
+      @Override public P1<A> weakMemo() { return this; }
+      @Override public P1<A> softMemo() { return this; }
     };
   }
 
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
@@ -1,5 +1,7 @@
 package fj;
 
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
 import java.lang.ref.WeakReference;
 
 import fj.data.Array;
@@ -208,53 +210,93 @@ public <X> P1<X> map(final F<A, X> f) {
       }
 
     /**
-       * Provides a memoising P1 that remembers its value.
-       *
-       * @return A P1 that calls this P1 once and remembers the value for subsequent calls.
-       */
-      public P1<A> memo() {
-        final P1<A> self = this;
-        return new P1<A>() {
-          private final Object latch = new Object();
-          private volatile WeakReference<Option<A>> v = null;
-
-          @Override
-          public A _1() {
-            Option<A> o = v != null ? v.get() : null;
-            if (o == null) {
-              synchronized (latch) {
-                o = v != null ? v.get() : null;
-                if (o == null) {
-                  o = Option.some(self._1());
-                  v = new WeakReference<>(o);
-                }
-              }
-            }
-            return o.some();
-          }
+     * Returns a P1 that remembers its value.
+     *
+     * @return A P1 that calls this P1 once and remembers the value for subsequent calls.
+     */
+    public P1<A> memo() { return new Memo<>(this); }
 
-          @Override
-          public P1<A> memo() {
-              return this;
-          }
+    /**
+     * Like <code>memo</code>, but the memoized value is wrapped into a <code>WeakReference</code>
+     */
+    public P1<A> weakMemo() { return new WeakReferenceMemo<>(this); }
 
-        };
-      }
+    /**
+     * Like <code>memo</code>, but the memoized value is wrapped into a <code>SoftReference</code>
+     */
+    public P1<A> softMemo() { return new SoftReferenceMemo<>(this); }
 
     static <A> P1<A> memo(F<Unit, A> f) {
         return P.lazy(f).memo();
     }
 
-    /**
-       * Returns a constant function that always uses this value.
-       *
-       * @return A constant function that always uses this value. 
-       */
-      public <B> F<B, A> constant() {
+    static class Memo<A> extends P1<A> {
+      private final P1<A> self;
+      private volatile boolean initialized;
+      private A value;
+
+      Memo(P1<A> self) { this.self = self; }
+
+      @Override public A _1() {
+        if (!initialized) {
+          synchronized (this) {
+            if (!initialized) {
+              A a = self._1();
+              value = a;
+              initialized = true;
+              return a;
+            }
+          }
+        }
+        return value;
+      }
+
+      @Override public P1<A> memo() { return this; }
+    }
+
+    abstract static class ReferenceMemo<A> extends P1<A> {
+      private final P1<A> self;
+      private final Object latch = new Object();
+      private volatile Reference<Option<A>> v = null;
+
+      ReferenceMemo(final P1<A> self) { this.self = self; }
 
-        return b -> P1.this._1();
+      @Override public A _1() {
+        Option<A> o = v != null ? v.get() : null;
+        if (o == null) {
+          synchronized (latch) {
+            o = v != null ? v.get() : null;
+            if (o == null) {
+              o = Option.some(self._1());
+              v = newReference(o);
+            }
+          }
+        }
+        return o.some();
       }
 
+      abstract Reference<Option<A>> newReference(Option<A> o);
+    }
+
+    static class WeakReferenceMemo<A> extends ReferenceMemo<A> {
+      WeakReferenceMemo(P1<A> self) { super(self); }
+      @Override Reference<Option<A>> newReference(final Option<A> o) { return new WeakReference<>(o); }
+      @Override public P1<A> weakMemo() { return this; }
+    }
+
+    static class SoftReferenceMemo<A> extends ReferenceMemo<A> {
+      SoftReferenceMemo(P1<A> self) { super(self); }
+      @Override Reference<Option<A>> newReference(final Option<A> o) { return new SoftReference<>(o); }
+      @Override public P1<A> softMemo() { return this; }
+    }
+
+    /**
+     * Returns a constant function that always uses this value.
+     *
+     * @return A constant function that always uses this value.
+     */
+    public <B> F<B, A> constant() { return Function.constant(_1()); }
+
     @Override
     public String toString() {
 		return Show.p1Show(Show.<A>anyShow()).showS(this);
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
@@ -1430,7 +1430,7 @@ private static final class Cons<A> extends Stream<A> {
 
     Cons(final A head, final P1<Stream<A>> tail) {
       this.head = head;
-      this.tail = tail.memo();
+      this.tail = tail.weakMemo();
     }
 
     public A head() {

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,8 @@ public static <A> P1<A> p(final A a) {`
`37`	`37`	`return a;`
`38`	`38`	`}`
`39`	`39`	`@Override public P1<A> memo() { return this; }`
	`40`	`+ @Override public P1<A> weakMemo() { return this; }`
	`41`	`+ @Override public P1<A> softMemo() { return this; }`
`40`	`42`	`};`
`41`	`43`	`}`
`42`	`44`
Original file line number	Diff line number	Diff line change
`@@ -1430,7 +1430,7 @@ private static final class Cons<A> extends Stream<A> {`
`1430`	`1430`
`1431`	`1431`	`Cons(final A head, final P1<Stream<A>> tail) {`
`1432`	`1432`	`this.head = head;`
`1433`		`- this.tail = tail.memo();`
	`1433`	`+ this.tail = tail.weakMemo();`
`1434`	`1434`	`}`
`1435`	`1435`
`1436`	`1436`	`public A head() {`