WIP

jnape · jnape · commit 5bfd1c82d6a8 · 2017-01-23T21:44:22.000-06:00
diff --git a/src/main/java/com/jnape/palatable/lambda/recursionschemes/Thunk.java b/src/main/java/com/jnape/palatable/lambda/recursionschemes/Thunk.java
@@ -0,0 +1,24 @@
+package com.jnape.palatable.lambda.recursionschemes;
+
+import com.jnape.palatable.lambda.functor.Functor;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public final class Thunk<A, F extends Functor> implements Functor<A, Thunk<?, F>>, Supplier<Functor<A, F>> {
+    private final Supplier<Functor<A, F>> supplier;
+
+    public Thunk(Supplier<Functor<A, F>> supplier) {
+        this.supplier = supplier;
+    }
+
+    @Override
+    public <B> Thunk<B, F> fmap(Function<? super A, ? extends B> fn) {
+        return new Thunk<>(() -> supplier.get().fmap(fn));
+    }
+
+    @Override
+    public Functor<A, F> get() {
+        return supplier.get();
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/recursionschemes/builtin/Anamorphism.java b/src/main/java/com/jnape/palatable/lambda/recursionschemes/builtin/Anamorphism.java
@@ -4,9 +4,10 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.functor.Functor;
 import com.jnape.palatable.lambda.recursionschemes.Fix;
+import com.jnape.palatable.lambda.recursionschemes.Thunk;
 import fix.Coalgebra;
 
-import static com.jnape.palatable.lambda.recursionschemes.Fix.fix;
+import static com.jnape.palatable.lambda.recursionschemes.builtin.Hylomorphism.hylo;
 
 public final class Anamorphism<A, F extends Functor, FA extends Functor<A, F>> implements Fn2<Coalgebra<A, FA>, A, Fix<F, Functor<Fix<F, ?>, F>>> {
 
@@ -17,7 +18,12 @@ private Anamorphism() {
 
     @Override
     public Fix<F, Functor<Fix<F, ?>, F>> apply(Coalgebra<A, FA> coalgebra, A a) {
-        return fix(coalgebra.apply(a).fmap(x -> ana(coalgebra, x)));
+        return hylo(f -> () -> new Thunk<>(() -> {
+            f.fmap(fixed -> coalgebra.apply(fixed.unfix()))
+            FA apply = coalgebra.apply(a);
+            return apply;
+        }).<Fix<F, ?>>fmap(a1 -> ana(coalgebra, a1)).get(), coalgebra, a);
+
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/recursionschemes/builtin/Hylomorphism.java b/src/main/java/com/jnape/palatable/lambda/recursionschemes/builtin/Hylomorphism.java
@@ -7,20 +7,36 @@
 import com.jnape.palatable.lambda.recursionschemes.Algebra;
 import fix.Coalgebra;
 
-import static com.jnape.palatable.lambda.recursionschemes.builtin.Anamorphism.ana;
-import static com.jnape.palatable.lambda.recursionschemes.builtin.Catamorphism.cata;
-
 public final class Hylomorphism<A, B, F extends Functor, FA extends Functor<A, F>, FB extends Functor<B, F>> implements Fn3<Algebra<FB, B>, Coalgebra<A, FA>, A, B> {
 
     private static final Hylomorphism INSTANCE = new Hylomorphism();
 
     private Hylomorphism() {
     }
 
+    @SuppressWarnings("unchecked")
+    public A fapply(Algebra<FA, A> algebra, Coalgebra<A, FA> coalgebra, A a) {
+        A x = a;
+        FA fa = coalgebra.apply(x);
+        FA previous = null;
+        while (fa != previous) {
+            previous = fa;
+            if (fa.fmap(a1 -> algebra.apply(coalgebra.apply(a1))).equals(fa))
+                return x;
+            x = algebra.apply(previous);
+            fa = coalgebra.apply(algebra.apply(fa));
+        }
+
+        return x;
+//
+//        return algebra.apply((FB) coalgebra.apply(a).fmap(hylo(algebra, coalgebra)));
+//        return cata(algebra).compose(ana(coalgebra)).apply(a);
+    }
+
     @Override
     @SuppressWarnings("unchecked")
     public B apply(Algebra<FB, B> algebra, Coalgebra<A, FA> coalgebra, A a) {
-        return cata(algebra).compose(ana(coalgebra)).apply(a);
+        return algebra.apply((FB) coalgebra.apply(a).fmap(hylo(algebra, coalgebra)));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/com/jnape/palatable/lambda/recursionschemes/builtin/AnamorphismTest.java b/src/test/java/com/jnape/palatable/lambda/recursionschemes/builtin/AnamorphismTest.java
@@ -1,5 +1,6 @@
 package com.jnape.palatable.lambda.recursionschemes.builtin;
 
+import com.jnape.palatable.lambda.recursionschemes.Algebra;
 import com.jnape.palatable.lambda.recursionschemes.Fix;
 import fix.Coalgebra;
 import org.junit.Test;
@@ -23,4 +24,17 @@ public void unfoldingToGreatestFixedPoint() {
         assertEquals(Fix.<ListF<Integer, ?>, ListF<Integer, Fix<ListF<Integer, ?>, ?>>>fix(ListF.cons(0, fix(ListF.cons(1, fix(ListF.cons(2, fix(ListF.nil()))))))),
                      ana(elements, 0));
     }
+
+    @Test
+    public void unfoldingInfiniteCodata() {
+        Coalgebra<Integer, NatF<Integer>> naturals = i -> {
+            if (i % 10000 == 0)
+                System.out.println("i = " + i);
+            return NatF.s(i + 1);
+        };
+        Algebra<NatF<Integer>, Integer> sum = nat -> nat.match(z -> 0, s -> s.carrier() + 1);
+        Integer x = Hylomorphism.<Integer, Integer, NatF, NatF<Integer>, NatF<Integer>>hylo().fapply(sum, naturals, 0);
+        System.out.println(x);
+
+    }
 }
