Make _1() method of memoized P1s smaller

jbgi · jbgi · commit ac116dfa81a1 · 2016-10-23T11:48:57.000+02:00
so that the fast path can be inlined by the jvm.
Also replaced Option by P1 in implementation,
also avoid wrapping some more memoized instances.
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
@@ -1,15 +1,17 @@
 package fj;
 
-import java.lang.ref.Reference;
-import java.lang.ref.SoftReference;
-import java.lang.ref.WeakReference;
-
 import fj.data.Array;
-import fj.data.List;
-import fj.data.Stream;
 import fj.data.Either;
+import fj.data.List;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.Validation;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+
+import static fj.P.p;
 //import fj.data.*;
 
 
@@ -138,7 +140,7 @@ public final <B, C> P1<C> liftM2(P1<B> pb, F2<A, B, C> f) {
      * @return A single P1 for the given List.
      */
     public static <A> P1<List<A>> sequence(final List<P1<A>> as) {
-        return as.foldRight(liftM2(List.cons()), P.p(List.nil()));
+        return as.foldRight(liftM2(List.cons()), p(List.nil()));
     }
 
     /**
@@ -157,7 +159,7 @@ public static <A> F<List<P1<A>>, P1<List<A>>> sequenceList() {
      * @return A single P1 for the given stream.
      */
     public static <A> P1<Stream<A>> sequence(final Stream<P1<A>> as) {
-        return as.foldRight(liftM2(Stream.cons()), P.p(Stream.nil()));
+        return as.foldRight(liftM2(Stream.cons()), p(Stream.nil()));
     }
 
 	/**
@@ -238,7 +240,7 @@ public final <B> P1<B> map(final F<A, B> f) {
         return P.lazy(() -> f.f(self._1()));
       }
 
-    public P1<A> memo() {
+    public final P1<A> memo() {
         return weakMemo();
     }
 
@@ -247,7 +249,7 @@ public P1<A> memo() {
      *
      * @return A P1 that calls this P1 once and remembers the value for subsequent calls.
      */
-    public final P1<A> hardMemo() { return new Memo<>(this); }
+    public P1<A> hardMemo() { return new Memo<>(this); }
 
     /**
      * Like <code>memo</code>, but the memoized value is wrapped into a <code>WeakReference</code>
@@ -267,65 +269,69 @@ public static <A> P1<A> memo(F0<A> f) {
 		return P.lazy(f).memo();
 	}
 
-    static class Memo<A> extends P1<A> {
+    static final class Memo<A> extends P1<A> {
       private volatile P1<A> self;
       private A value;
 
       Memo(P1<A> self) { this.self = self; }
 
       @Override public final A _1() {
+        return (self == null) ? value : computeValue();
+      }
+
+      private synchronized A computeValue() {
+        P1<A> self = this.self;
         if (self != null) {
-          synchronized (this) {
-            if (self != null) {
-              A a = self._1();
-              value = a;
-              self = null;
-              return a;
-            }
-          }
+          value = self._1();
+          this.self = null;
         }
         return value;
       }
 
-      @Override public final P1<A> memo() { return this; }
+      @Override public P1<A> hardMemo() { return this; }
+      @Override public P1<A> softMemo() { return this; }
+      @Override public P1<A> weakMemo() { 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;
+      private volatile Reference<P1<A>> v = null;
 
       ReferenceMemo(final P1<A> self) { this.self = self; }
 
       @Override public final 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);
-            }
-          }
+        Reference<P1<A>> v = this.v;
+        P1<A> p1 = v != null ? v.get() : null;
+        return p1 != null ? p1._1() : computeValue();
+      }
+
+      private synchronized A computeValue() {
+        Reference<P1<A>> v = this.v;
+        P1<A> p1 = v != null ? v.get() : null;
+        if (p1 == null) {
+          A a = self._1();
+          this.v = newReference(p(a));
+          return a;
         }
-        return o.some();
+        return p1._1();
       }
 
-      abstract Reference<Option<A>> newReference(Option<A> o);
+      abstract <B> Reference<B> newReference(B ref);
     }
 
-    static class WeakReferenceMemo<A> extends ReferenceMemo<A> {
+    static final class WeakReferenceMemo<A> extends ReferenceMemo<A> {
       WeakReferenceMemo(P1<A> self) { super(self); }
       @Override
-      final Reference<Option<A>> newReference(final Option<A> o) { return new WeakReference<>(o); }
-      @Override public final P1<A> weakMemo() { return this; }
+      <B> Reference<B> newReference(final B ref) { return new WeakReference<>(ref); }
+      @Override public P1<A> weakMemo() { return this; }
     }
 
-    static class SoftReferenceMemo<A> extends ReferenceMemo<A> {
+    static final class SoftReferenceMemo<A> extends ReferenceMemo<A> {
       SoftReferenceMemo(P1<A> self) { super(self); }
       @Override
-      final Reference<Option<A>> newReference(final Option<A> o) { return new SoftReference<>(o); }
-      @Override public final P1<A> softMemo() { return this; }
+      <B> Reference<B> newReference(final B ref) { return new SoftReference<>(ref); }
+      @Override public P1<A> softMemo() { return this; }
+      @Override public P1<A> weakMemo() { return this; }
     }
 
     /**
