Fn1#withSelf for writing self-referencing Fn1s

jnape · jnape · commit 3e6f644320bf · 2020-04-22T18:08:38.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Added
 - `$`, function application represented as a higher-order `Fn2`
+- `Fn1#withSelf`, a static method for constructing a self-referencing `Fn1` 
 
 ## [5.2.0] - 2020-02-12
 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
@@ -302,6 +302,10 @@ default <C, D> Fn2<A, C, D> andThen(Fn2<? super B, ? super C, ? extends D> after
         return (a, c) -> after.apply(apply(a), c);
     }
 
+    default Fn1<A, B> self() {
+        return this;
+    }
+
     /**
      * Static factory method for avoid explicit casting when using method references as {@link Fn1}s.
      *
@@ -335,4 +339,17 @@ static <A, B> Fn1<A, B> fromFunction(Function<? super A, ? extends B> function)
     static <A> Pure<Fn1<A, ?>> pureFn1() {
         return Constantly::constantly;
     }
+
+    /**
+     * Construct an {@link Fn1} that has a reference to itself in scope at the time it is executed (presumably for
+     * recursive invocations).
+     *
+     * @param fn  the body of the function, with access to itself
+     * @param <A> the input type
+     * @param <B> the output type
+     * @return the {@link Fn1}
+     */
+    static <A, B> Fn1<A, B> withSelf(Fn2<? super Fn1<? super A, ? extends B>, ? super A, ? extends B> fn) {
+        return a -> fn.apply(withSelf(fn), a);
+    }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
@@ -8,8 +8,8 @@
 import testsupport.traits.Equivalence;
 import testsupport.traits.FunctorLaws;
 import testsupport.traits.MonadLaws;
-import testsupport.traits.MonadRecLaws;
 import testsupport.traits.MonadReaderLaws;
+import testsupport.traits.MonadRecLaws;
 import testsupport.traits.MonadWriterLaws;
 
 import java.util.function.Function;
@@ -105,4 +105,9 @@ public void staticPure() {
         Fn1<String, Integer> fn1 = Fn1.<String>pureFn1().apply(1);
         assertEquals((Integer) 1, fn1.apply("anything"));
     }
+
+    @Test
+    public void withSelf() {
+        assertEquals((Integer) 15, Fn1.<Integer, Integer>withSelf((f, x) -> x > 1 ? x + f.apply(x - 1) : x).apply(5));
+    }
 }
