From 641ad933b14d884ada9a6cb6d1a60366afd55b5d Mon Sep 17 00:00:00 2001 From: jnape Date: Mon, 27 Jun 2016 22:41:20 -0500 Subject: [PATCH 01/11] [maven-release-plugin] prepare for next development iteration --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 30e571f91..d3b197e90 100644 --- a/pom.xml +++ b/pom.xml @@ -9,7 +9,7 @@ lambda - 1.2 + 1.3-SNAPSHOT jar Lambda From 1148454baf4f30c990913429d2977dcdf15fb51c Mon Sep 17 00:00:00 2001 From: jnape Date: Mon, 27 Jun 2016 22:58:07 -0500 Subject: [PATCH 02/11] Updating README --- README.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/README.md b/README.md index 076a31dad..6749174eb 100644 --- a/README.md +++ b/README.md @@ -187,6 +187,21 @@ Finally, all `Tuple*` classes are instances of both `Functor` and `Bifunctor`: System.out.println(mappedTuple3._3()); // prints 2 ``` +### Heterogeneous Maps + +HMaps are type-safe heterogeneous maps, meaning they can store mappings to different value types in the same map; however, whereas HLists encode value types in their type signatures, HMaps rely on the keys to encode the value type that they point to. + +```Java + TypeSafeKey stringKey = TypeSafeKey.typeSafeKey(); + TypeSafeKey intKey = TypeSafeKey.typeSafeKey(); + HMap hmap = HMap.hMap(stringKey, "string value", + intKey, 1); + + Optional stringValue = hmap.get(stringKey); // Optional["string value"] + Optional intValue = hmap.get(intKey); // Optional[1] + Optional anotherIntValue = hmap.get(anotherIntKey); // Optional.empty +``` + ### Either Binary tagged unions are represented as `Either`s, which resolve to one of two possible values: a `Left` value wrapping an `L`, or a `Right` value wrapping an `R` (typically an exceptional value or a successful value, respectively). From afde277b0500e1bca43d1f7a5db58c65d2da4015 Mon Sep 17 00:00:00 2001 From: jnape Date: Mon, 27 Jun 2016 23:01:10 -0500 Subject: [PATCH 03/11] Updating README with latest maven version --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6749174eb..42e7c0d1a 100644 --- a/README.md +++ b/README.md @@ -32,14 +32,14 @@ Add the following dependency to your: com.jnape.palatable lambda - 1.1 + 1.2 ``` `build.gradle` ([Gradle](https://docs.gradle.org/current/userguide/dependency_management.html)): ```gradle - compile group: 'com.jnape.palatable', name: 'lambda', version: '1.1' + compile group: 'com.jnape.palatable', name: 'lambda', version: '1.2' ``` From 971737676262f30a308386b22c55bcba5bc3cd25 Mon Sep 17 00:00:00 2001 From: jnape Date: Sun, 3 Jul 2016 12:02:20 -0400 Subject: [PATCH 04/11] Fixed Profunctor inheritance problems around functions --- .../lambda/functions/DyadicFunction.java | 21 +-------------- .../lambda/functions/MonadicFunction.java | 18 ++++++++++++- .../palatable/lambda/functor/Profunctor.java | 9 +++---- .../lambda/functions/DyadicFunctionTest.java | 26 +++++++++---------- .../lambda/functions/TriadicFunctionTest.java | 22 +++++++++++++--- .../InvocationRecordingProfunctor.java | 7 +++-- 6 files changed, 56 insertions(+), 47 deletions(-) diff --git a/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java index b599cf797..197f264e1 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java @@ -1,7 +1,6 @@ package com.jnape.palatable.lambda.functions; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functor.Profunctor; /** * A function taking two arguments. Auto-curried. @@ -13,7 +12,7 @@ * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Partial2 */ @FunctionalInterface -public interface DyadicFunction extends MonadicFunction>, Profunctor { +public interface DyadicFunction extends MonadicFunction> { C apply(A a, B b); @@ -22,24 +21,6 @@ default MonadicFunction apply(A a) { return (b) -> apply(a, b); } - @Override - @SuppressWarnings("unchecked") - default DyadicFunction diMapL(MonadicFunction fn) { - return (DyadicFunction) Profunctor.super.diMapL(fn); - } - - @Override - @SuppressWarnings("unchecked") - default DyadicFunction diMapR(MonadicFunction fn) { - return (DyadicFunction) Profunctor.super.diMapR(fn); - } - - @Override - default DyadicFunction diMap(MonadicFunction f1, - MonadicFunction f2) { - return (a, d) -> f2.apply(apply(a, f1.apply(d))); - } - default DyadicFunction flip() { return (b, a) -> apply(a, b); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java index dddd2ec8c..18f505acd 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java @@ -1,6 +1,7 @@ package com.jnape.palatable.lambda.functions; import com.jnape.palatable.lambda.functor.Functor; +import com.jnape.palatable.lambda.functor.Profunctor; import java.util.function.Function; @@ -12,7 +13,7 @@ * @param The output type */ @FunctionalInterface -public interface MonadicFunction extends Functor, Function { +public interface MonadicFunction extends Functor, Profunctor, Function { B apply(A a); @@ -25,6 +26,21 @@ default MonadicFunction fmap(MonadicFunction g return a -> g.apply(apply(a)); } + @Override + default MonadicFunction diMapL(MonadicFunction fn) { + return (MonadicFunction) Profunctor.super.diMapL(fn); + } + + @Override + default MonadicFunction diMapR(MonadicFunction fn) { + return (MonadicFunction) Profunctor.super.diMapR(fn); + } + + @Override + default MonadicFunction diMap(MonadicFunction lFn, MonadicFunction rFn) { + return lFn.andThen(this).andThen(rFn); + } + @Override default MonadicFunction compose(Function before) { return z -> apply(before.apply(z)); diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java index edc79ab45..022ac8cd2 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java @@ -14,19 +14,18 @@ * @param The type of the second parameter * @see Functor * @see Bifunctor - * @see com.jnape.palatable.lambda.functions.DyadicFunction + * @see com.jnape.palatable.lambda.functions.MonadicFunction */ @FunctionalInterface public interface Profunctor { - default Profunctor diMapL(MonadicFunction fn) { + default Profunctor diMapL(MonadicFunction fn) { return diMap(fn, id()); } - default Profunctor diMapR(MonadicFunction fn) { + default Profunctor diMapR(MonadicFunction fn) { return diMap(id(), fn); } - Profunctor diMap(MonadicFunction f1, - MonadicFunction f2); + Profunctor diMap(MonadicFunction lFn, MonadicFunction rFn); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java index 8ec963682..913da6bb0 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java @@ -1,5 +1,6 @@ package com.jnape.palatable.lambda.functions; +import com.jnape.palatable.lambda.functions.builtin.monadic.Identity; import org.junit.Test; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; @@ -8,8 +9,8 @@ public class DyadicFunctionTest { - private static final DyadicFunction CHECK_LENGTH = (string, - length) -> string.length() == length; + private static final DyadicFunction CHECK_LENGTH + = (string, length) -> string.length() == length; @Test public void flipSwapsArguments() { @@ -27,22 +28,19 @@ public void uncurries() { } @Test - public void mapsContravariantlyOverSecondArgument() { - assertThat(CHECK_LENGTH.diMapL(Integer::parseInt).apply("123").apply("3"), is(true)); + public void functorProperties() { + assertThat(CHECK_LENGTH.fmap(f -> Identity.id()).apply("foo").apply("bar"), is("bar")); } @Test - public void mapsCovariantlyOverReturnValue() { - assertThat(CHECK_LENGTH.diMapR(Object::toString).apply("123").apply(3), is("true")); - } - - @Test - public void mapsOverSecondArgumentAndReturnValueInSingleTransformation() { + public void profunctorProperties() { + assertThat(CHECK_LENGTH.diMapL(Object::toString).apply(123).apply(3), is(true)); + assertThat(CHECK_LENGTH.diMapR(fn -> fn.andThen(Object::toString)).apply("123").apply(3), is("true")); assertThat( - CHECK_LENGTH.diMap( - Integer::parseInt, - Object::toString - ).apply("123", "3"), + CHECK_LENGTH.>diMap( + Object::toString, + fn -> fn.andThen(Object::toString) + ).apply("123").apply(3), is("true") ); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java index fd0d2478c..eb1463188 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java @@ -18,14 +18,30 @@ public void canBePartiallyApplied() { assertThat(CHECK_MULTIPLICATION.apply(2, 4).apply(8), is(true)); } + @Test + public void flipsFirstAndSecondArgument() { + TriadicFunction concat3 = (a, b, c) -> a + b.toString() + c; + assertThat(concat3.flip().apply(1, "2", "3"), is("213")); + } + @Test public void uncurries() { assertThat(CHECK_MULTIPLICATION.uncurry().apply(tuple(2, 3), 6), is(true)); } @Test - public void flipsFirstAndSecondArgument() { - TriadicFunction concat3 = (a, b, c) -> a + b.toString() + c; - assertThat(concat3.flip().apply(1, "2", "3"), is("213")); + public void functorProperties() { + assertThat(CHECK_MULTIPLICATION.fmap(f -> f.fmap(g -> g.andThen(Object::toString))).apply(2).apply(3).apply(6), is("true")); + } + + @Test + public void profunctorProperties() { + assertThat(CHECK_MULTIPLICATION.diMapL(Integer::parseInt).apply("2").apply(3).apply(6), is(true)); + assertThat(CHECK_MULTIPLICATION.diMapR(f -> f.fmap(g -> g.andThen(Object::toString))).apply(2).apply(3).apply(6), is("true")); + assertThat(CHECK_MULTIPLICATION.diMap((MonadicFunction) Integer::parseInt, + f -> f.fmap(g -> g.andThen(Object::toString))) + .apply("2") + .apply(3) + .apply(6), is("true")); } } diff --git a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java index 7cb8bef0d..8904c2afc 100644 --- a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java +++ b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java @@ -17,10 +17,9 @@ public InvocationRecordingProfunctor(AtomicReference leftFn, @Override @SuppressWarnings("unchecked") - public Profunctor diMap(MonadicFunction f1, - MonadicFunction f2) { - leftFn.set(f1); - rightFn.set(f2); + public Profunctor diMap(MonadicFunction lFn, MonadicFunction rFn) { + leftFn.set(lFn); + rightFn.set(rFn); return (Profunctor) this; } } From 692f9f5d6162d5598844e9423093f5ee2e16e9a4 Mon Sep 17 00:00:00 2001 From: jnape Date: Sat, 9 Jul 2016 00:16:47 -0500 Subject: [PATCH 05/11] Adding more private constructors --- .../jnape/palatable/lambda/functions/builtin/dyadic/All.java | 2 +- .../palatable/lambda/functions/builtin/monadic/Constantly.java | 2 +- .../palatable/lambda/functions/builtin/monadic/Cycle.java | 3 +++ .../palatable/lambda/functions/builtin/monadic/Identity.java | 3 +++ .../palatable/lambda/functions/builtin/monadic/Repeat.java | 3 +++ .../palatable/lambda/functions/builtin/monadic/Reverse.java | 3 +++ .../palatable/lambda/functions/builtin/triadic/FoldLeft.java | 3 +++ .../palatable/lambda/functions/builtin/triadic/FoldRight.java | 3 +++ .../palatable/lambda/functions/builtin/triadic/ScanLeft.java | 3 +++ .../palatable/lambda/functions/builtin/triadic/ZipWith.java | 3 +++ .../palatable/lambda/functions/builtin/monadic/CycleTest.java | 2 +- .../lambda/functions/builtin/monadic/IdentityTest.java | 3 ++- .../palatable/lambda/functions/builtin/monadic/RepeatTest.java | 2 +- 13 files changed, 30 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java index 768a76b0b..75645dfed 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java @@ -33,7 +33,7 @@ public static MonadicFunction, Boolean> all(MonadicFunctionall().apply(predicate); } - public static boolean all(MonadicFunction predicate, Iterable as) { + public static Boolean all(MonadicFunction predicate, Iterable as) { return All.all(predicate).apply(as); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java index 104bbf416..74f89b17e 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java @@ -12,7 +12,7 @@ public final class Constantly implements MonadicFunction { private final B b; - public Constantly(B b) { + private Constantly(B b) { this.b = b; } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java index cc1694f79..ec6c360ec 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java @@ -13,6 +13,9 @@ */ public final class Cycle implements MonadicFunction, Iterable> { + private Cycle() { + } + @Override public Iterable apply(Iterable as) { return () -> new CyclicIterator<>(as.iterator()); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java index 1f454e380..560a8cd65 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java @@ -11,6 +11,9 @@ public final class Identity implements MonadicFunction { private static final Identity IDENTITY = new Identity(); + private Identity() { + } + @Override public A apply(A a) { return a; diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java index 9f06e6e64..30e65ab8e 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java @@ -10,6 +10,9 @@ */ public final class Repeat implements MonadicFunction> { + private Repeat() { + } + @Override public Iterable apply(A a) { return () -> new RepetitiousIterator<>(a); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java index ad15f59c0..311ff5192 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java @@ -11,6 +11,9 @@ */ public final class Reverse implements MonadicFunction, Iterable> { + private Reverse() { + } + @Override public Iterable apply(Iterable as) { return () -> new ReversingIterator<>(as.iterator()); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java index d6c6810d1..03b9b7ad5 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java @@ -20,6 +20,9 @@ */ public final class FoldLeft implements TriadicFunction, B, Iterable, B> { + private FoldLeft() { + } + @Override public B apply(DyadicFunction function, B initialAccumulation, Iterable as) { diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java index 657f740ea..8d7f472c6 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java @@ -23,6 +23,9 @@ */ public final class FoldRight implements TriadicFunction, B, Iterable, B> { + private FoldRight() { + } + @Override public B apply(DyadicFunction function, B initialAccumulation, Iterable as) { return foldLeft(function.flip(), initialAccumulation, reverse(as)); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java index d00dd9fa9..daf727e18 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java @@ -21,6 +21,9 @@ */ public final class ScanLeft implements TriadicFunction, B, Iterable, Iterable> { + private ScanLeft() { + } + @Override public Iterable apply(DyadicFunction fn, B b, Iterable as) { return () -> new ScanningIterator<>(fn, b, as.iterator()); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java index 817218f1e..9f2687296 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java @@ -17,6 +17,9 @@ */ public final class ZipWith implements TriadicFunction, Iterable, Iterable, Iterable> { + private ZipWith() { + } + @Override public Iterable apply(DyadicFunction zipper, Iterable as, Iterable bs) { return () -> new ZippingIterator<>(zipper, as.iterator(), bs.iterator()); diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java index 4025ebc5a..4475989e7 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java @@ -18,7 +18,7 @@ public class CycleTest { @TestTraits({Laziness.class, ImmutableIteration.class, InfiniteIteration.class}) public Cycle createTestSubject() { - return new Cycle(); + return cycle(); } @Test diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java index 8d4912d0e..8bc412c1e 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java @@ -2,6 +2,7 @@ import org.junit.Test; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; @@ -9,6 +10,6 @@ public class IdentityTest { @Test public void returnsInput() { - assertThat(new Identity().apply("anything"), is("anything")); + assertThat(id().apply("anything"), is("anything")); } } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java index ab779679a..6e15d8634 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java @@ -18,7 +18,7 @@ public class RepeatTest { @TestTraits({Laziness.class, ImmutableIteration.class, InfiniteIteration.class}) public Repeat createTestSubject() { - return new Repeat(); + return repeat(); } @Test From 0d37137f853e8ed78d3b6d9299e227afaf3b2222 Mon Sep 17 00:00:00 2001 From: jnape Date: Sat, 9 Jul 2016 13:49:46 -0500 Subject: [PATCH 06/11] Constantly is now true-to-form dyadic --- .../functions/builtin/monadic/Constantly.java | 30 +++++++++++-------- 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java index 74f89b17e..4e08f87a5 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java @@ -1,27 +1,33 @@ package com.jnape.palatable.lambda.functions.builtin.monadic; +import com.jnape.palatable.lambda.functions.DyadicFunction; import com.jnape.palatable.lambda.functions.MonadicFunction; /** - * Given a value, produce a function that returns that value, regardless of input. + * A function that takes two arguments and always returns the first argument. * - * @param The input type of the resulting function - * @param The output type of the resulting function + * @param The first argument type, and the the function's return type + * @param The second (ignored) argument type */ -public final class Constantly implements MonadicFunction { +public final class Constantly implements DyadicFunction { - private final B b; - - private Constantly(B b) { - this.b = b; + private Constantly() { } @Override - public B apply(A a) { - return b; + public A apply(A a, B b) { + return a; + } + + public static Constantly constantly() { + return new Constantly<>(); + } + + public static MonadicFunction constantly(A a) { + return Constantly.constantly().apply(a); } - public static MonadicFunction constantly(B b) { - return new Constantly<>(b); + public static A constantly(A a, B b) { + return constantly(a).apply(b); } } From d218d4436d99d40944435cdf3a59be9f55d7108f Mon Sep 17 00:00:00 2001 From: jnape Date: Sun, 10 Jul 2016 00:20:38 -0500 Subject: [PATCH 07/11] Shortening Identity to Id --- .../java/com/jnape/palatable/lambda/adt/Either.java | 2 +- .../builtin/monadic/{Identity.java => Id.java} | 10 +++++----- .../com/jnape/palatable/lambda/functor/Bifunctor.java | 2 +- .../com/jnape/palatable/lambda/functor/Profunctor.java | 2 +- .../palatable/lambda/functions/DyadicFunctionTest.java | 4 ++-- .../lambda/functions/builtin/dyadic/MapTest.java | 2 +- .../builtin/monadic/{IdentityTest.java => IdTest.java} | 4 ++-- .../jnape/palatable/lambda/functor/BifunctorTest.java | 2 +- .../jnape/palatable/lambda/functor/ProfunctorTest.java | 2 +- 9 files changed, 15 insertions(+), 15 deletions(-) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/{Identity.java => Id.java} (57%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/{IdentityTest.java => IdTest.java} (88%) diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java index b286f7d54..aa4367a6d 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/Either.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/Either.java @@ -11,7 +11,7 @@ import java.util.function.Consumer; import java.util.function.Supplier; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; /** * The binary tagged union. General semantics tend to connote "success" values via the right value and "failure" values diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Id.java similarity index 57% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Id.java index 560a8cd65..5a6d0abb4 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Identity.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Id.java @@ -7,11 +7,11 @@ * * @param The input/output type */ -public final class Identity implements MonadicFunction { +public final class Id implements MonadicFunction { - private static final Identity IDENTITY = new Identity(); + private static final Id ID = new Id(); - private Identity() { + private Id() { } @Override @@ -20,7 +20,7 @@ public A apply(A a) { } @SuppressWarnings("unchecked") - public static Identity id() { - return (Identity) IDENTITY; + public static Id id() { + return (Id) ID; } } diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java index 903aa463f..c410b6f19 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java @@ -2,7 +2,7 @@ import com.jnape.palatable.lambda.functions.MonadicFunction; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; /** * A dually-parametric Functor that maps covariantly over both parameters. diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java index 022ac8cd2..cdde4a6f5 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java @@ -2,7 +2,7 @@ import com.jnape.palatable.lambda.functions.MonadicFunction; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; /** * A dually-parametric Functor that maps contravariantly over the first parameter and covariantly over the diff --git a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java index 913da6bb0..02a211686 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java @@ -1,6 +1,6 @@ package com.jnape.palatable.lambda.functions; -import com.jnape.palatable.lambda.functions.builtin.monadic.Identity; +import com.jnape.palatable.lambda.functions.builtin.monadic.Id; import org.junit.Test; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; @@ -29,7 +29,7 @@ public void uncurries() { @Test public void functorProperties() { - assertThat(CHECK_LENGTH.fmap(f -> Identity.id()).apply("foo").apply("bar"), is("bar")); + assertThat(CHECK_LENGTH.fmap(f -> Id.id()).apply("foo").apply("bar"), is("bar")); } @Test diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java index 8b2d5b5ce..e6d87d765 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java @@ -11,7 +11,7 @@ import testsupport.traits.Laziness; import static com.jnape.palatable.lambda.functions.builtin.dyadic.Map.map; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdTest.java similarity index 88% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdTest.java index 8bc412c1e..0d755a717 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdentityTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdTest.java @@ -2,11 +2,11 @@ import org.junit.Test; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; -public class IdentityTest { +public class IdTest { @Test public void returnsInput() { diff --git a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java index d5b779e6d..d8433c53a 100644 --- a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java @@ -6,7 +6,7 @@ import java.util.concurrent.atomic.AtomicReference; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; diff --git a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java index d99fb1478..9c0252620 100644 --- a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java @@ -6,7 +6,7 @@ import java.util.concurrent.atomic.AtomicReference; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Identity.id; +import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; From e037f58db67e88043acd40dffa19591584f880e0 Mon Sep 17 00:00:00 2001 From: jnape Date: Sun, 10 Jul 2016 00:30:28 -0500 Subject: [PATCH 08/11] Renaming MonadicFunction/DyadicFunction/TriadicFunction across the board to Fn1/Fn2/Fn3 respectively --- README.md | 18 +++---- .../jnape/palatable/lambda/adt/Either.java | 48 ++++++++--------- .../palatable/lambda/adt/hlist/Singleton.java | 4 +- .../palatable/lambda/adt/hlist/Tuple2.java | 12 ++--- .../palatable/lambda/adt/hlist/Tuple3.java | 12 ++--- .../palatable/lambda/adt/hlist/Tuple4.java | 12 ++--- .../palatable/lambda/adt/hlist/Tuple5.java | 12 ++--- .../jnape/palatable/lambda/adt/hmap/HMap.java | 2 +- .../jnape/palatable/lambda/functions/Fn1.java | 53 ++++++++++++++++++ .../{DyadicFunction.java => Fn2.java} | 12 ++--- .../{TriadicFunction.java => Fn3.java} | 16 +++--- .../lambda/functions/MonadicFunction.java | 53 ------------------ .../lambda/functions/builtin/dyadic/Map.java | 36 ------------- .../functions/builtin/dyadic/Partial2.java | 36 ------------- .../functions/builtin/dyadic/Partial3.java | 39 -------------- .../functions/builtin/dyadic/ReduceLeft.java | 52 ------------------ .../functions/builtin/dyadic/ReduceRight.java | 49 ----------------- .../builtin/{monadic => fn1}/Constantly.java | 10 ++-- .../builtin/{monadic => fn1}/Cycle.java | 6 +-- .../builtin/{monadic => fn1}/Id.java | 6 +-- .../builtin/{monadic => fn1}/Repeat.java | 6 +-- .../builtin/{monadic => fn1}/Reverse.java | 6 +-- .../builtin/{dyadic => fn2}/All.java | 14 ++--- .../builtin/{dyadic => fn2}/Any.java | 14 ++--- .../{dyadic => fn2}/CartesianProduct.java | 10 ++-- .../builtin/{dyadic => fn2}/Drop.java | 10 ++-- .../builtin/{dyadic => fn2}/DropWhile.java | 15 +++--- .../builtin/{dyadic => fn2}/Filter.java | 14 ++--- .../builtin/{dyadic => fn2}/InGroupsOf.java | 10 ++-- .../builtin/{dyadic => fn2}/Iterate.java | 14 ++--- .../lambda/functions/builtin/fn2/Map.java | 35 ++++++++++++ .../functions/builtin/fn2/Partial2.java | 36 +++++++++++++ .../functions/builtin/fn2/Partial3.java | 38 +++++++++++++ .../functions/builtin/fn2/ReduceLeft.java | 50 +++++++++++++++++ .../functions/builtin/fn2/ReduceRight.java | 46 ++++++++++++++++ .../builtin/{dyadic => fn2}/Take.java | 10 ++-- .../builtin/{dyadic => fn2}/TakeWhile.java | 16 +++--- .../builtin/{dyadic => fn2}/Tupler2.java | 10 ++-- .../builtin/{dyadic => fn2}/Unfoldr.java | 20 +++---- .../builtin/{dyadic => fn2}/Zip.java | 16 +++--- .../functions/builtin/fn3/FoldLeft.java | 49 +++++++++++++++++ .../functions/builtin/fn3/FoldRight.java | 49 +++++++++++++++++ .../functions/builtin/fn3/ScanLeft.java | 44 +++++++++++++++ .../lambda/functions/builtin/fn3/ZipWith.java | 46 ++++++++++++++++ .../functions/builtin/triadic/FoldLeft.java | 53 ------------------ .../functions/builtin/triadic/FoldRight.java | 52 ------------------ .../functions/builtin/triadic/ScanLeft.java | 54 ------------------- .../functions/builtin/triadic/ZipWith.java | 46 ---------------- .../functions/specialized/Predicate.java | 6 +-- ...edMonadicFunction.java => CheckedFn1.java} | 8 +-- .../specialized/checked/CheckedSupplier.java | 2 +- .../palatable/lambda/functor/Bifunctor.java | 12 ++--- .../palatable/lambda/functor/Functor.java | 6 +-- .../palatable/lambda/functor/Profunctor.java | 12 ++--- .../lambda/iterators/FilteringIterator.java | 8 +-- .../lambda/iterators/MappingIterator.java | 8 +-- .../iterators/PredicatedDroppingIterator.java | 10 ++-- .../iterators/PredicatedTakingIterator.java | 10 ++-- .../lambda/iterators/RewindableIterator.java | 1 + .../lambda/iterators/ScanningIterator.java | 10 ++-- .../lambda/iterators/UnfoldingIterator.java | 8 +-- .../lambda/iterators/ZippingIterator.java | 10 ++-- .../palatable/lambda/adt/EitherTest.java | 6 +-- ...{MonadicFunctionTest.java => Fn1Test.java} | 10 ++-- .../{DyadicFunctionTest.java => Fn2Test.java} | 8 +-- ...{TriadicFunctionTest.java => Fn3Test.java} | 8 +-- .../builtin/dyadic/Partial2Test.java | 18 ------- .../builtin/dyadic/Partial3Test.java | 18 ------- .../{monadic => fn1}/ConstantlyTest.java | 4 +- .../builtin/{monadic => fn1}/CycleTest.java | 6 +-- .../builtin/{monadic => fn1}/IdTest.java | 4 +- .../builtin/{monadic => fn1}/RepeatTest.java | 6 +-- .../builtin/{monadic => fn1}/ReverseTest.java | 4 +- .../builtin/{dyadic => fn2}/AllTest.java | 14 ++--- .../builtin/{dyadic => fn2}/AnyTest.java | 14 ++--- .../{dyadic => fn2}/CartesianProductTest.java | 8 +-- .../builtin/{dyadic => fn2}/DropTest.java | 8 +-- .../{dyadic => fn2}/DropWhileTest.java | 10 ++-- .../builtin/{dyadic => fn2}/FilterTest.java | 10 ++-- .../{dyadic => fn2}/InGroupsOfTest.java | 11 ++-- .../builtin/{dyadic => fn2}/IterateTest.java | 12 ++--- .../builtin/{dyadic => fn2}/MapTest.java | 12 ++--- .../functions/builtin/fn2/Partial2Test.java | 18 +++++++ .../functions/builtin/fn2/Partial3Test.java | 18 +++++++ .../{dyadic => fn2}/ReduceLeftTest.java | 4 +- .../{dyadic => fn2}/ReduceRightTest.java | 4 +- .../builtin/{dyadic => fn2}/TakeTest.java | 11 ++-- .../{dyadic => fn2}/TakeWhileTest.java | 10 ++-- .../builtin/{dyadic => fn2}/Tupler2Test.java | 4 +- .../builtin/{dyadic => fn2}/UnfoldrTest.java | 10 ++-- .../builtin/{dyadic => fn2}/ZipTest.java | 8 +-- .../{triadic => fn3}/FoldLeftTest.java | 11 ++-- .../{triadic => fn3}/FoldRightTest.java | 11 ++-- .../{triadic => fn3}/ScanLeftTest.java | 8 +-- .../builtin/{triadic => fn3}/ZipWithTest.java | 14 ++--- .../lambda/functor/BifunctorTest.java | 8 +-- .../lambda/functor/ProfunctorTest.java | 8 +-- .../lambda/iterators/MappingIteratorTest.java | 4 +- .../PredicatedDroppingIteratorTest.java | 4 +- .../iterators/ScanningIteratorTest.java | 3 +- .../iterators/UnfoldingIteratorTest.java | 4 +- .../lambda/iterators/ZippingIteratorTest.java | 8 +-- .../InvocationRecordingBifunctor.java | 14 ++--- .../InvocationRecordingProfunctor.java | 12 ++--- .../testsupport/functions/ExplainFold.java | 4 +- .../traits/EmptyIterableSupport.java | 6 +-- .../testsupport/traits/FiniteIteration.java | 6 +-- .../traits/ImmutableIteration.java | 6 +-- .../testsupport/traits/InfiniteIteration.java | 6 +-- .../java/testsupport/traits/Laziness.java | 6 +-- 110 files changed, 892 insertions(+), 911 deletions(-) create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/Fn1.java rename src/main/java/com/jnape/palatable/lambda/functions/{DyadicFunction.java => Fn2.java} (58%) rename src/main/java/com/jnape/palatable/lambda/functions/{TriadicFunction.java => Fn3.java} (55%) delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/Constantly.java (64%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/Cycle.java (78%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/Id.java (63%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/Repeat.java (73%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/Reverse.java (76%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/All.java (52%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Any.java (52%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/CartesianProduct.java (78%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Drop.java (71%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/DropWhile.java (53%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Filter.java (55%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/InGroupsOf.java (71%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Iterate.java (60%) create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Take.java (69%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/TakeWhile.java (53%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Tupler2.java (70%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Unfoldr.java (61%) rename src/main/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Zip.java (61%) create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java create mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java delete mode 100644 src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java rename src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/{CheckedMonadicFunction.java => CheckedFn1.java} (67%) rename src/test/java/com/jnape/palatable/lambda/functions/{MonadicFunctionTest.java => Fn1Test.java} (58%) rename src/test/java/com/jnape/palatable/lambda/functions/{DyadicFunctionTest.java => Fn2Test.java} (83%) rename src/test/java/com/jnape/palatable/lambda/functions/{TriadicFunctionTest.java => Fn3Test.java} (82%) delete mode 100644 src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java delete mode 100644 src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/ConstantlyTest.java (68%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/CycleTest.java (77%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/IdTest.java (64%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/RepeatTest.java (77%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{monadic => fn1}/ReverseTest.java (91%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/AllTest.java (61%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/AnyTest.java (61%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/CartesianProductTest.java (86%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/DropTest.java (73%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/DropWhileTest.java (77%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/FilterTest.java (73%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/InGroupsOfTest.java (79%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/IterateTest.java (63%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/MapTest.java (67%) create mode 100644 src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java create mode 100644 src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/ReduceLeftTest.java (83%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/ReduceRightTest.java (83%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/TakeTest.java (76%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/TakeWhileTest.java (79%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/Tupler2Test.java (68%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/UnfoldrTest.java (70%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{dyadic => fn2}/ZipTest.java (78%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{triadic => fn3}/FoldLeftTest.java (64%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{triadic => fn3}/FoldRightTest.java (64%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{triadic => fn3}/ScanLeftTest.java (79%) rename src/test/java/com/jnape/palatable/lambda/functions/builtin/{triadic => fn3}/ZipWithTest.java (74%) diff --git a/README.md b/README.md index 42e7c0d1a..2dd80178d 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,7 @@ First, the obligatory `map`/`filter`/`reduce` example: Every function in lambda is [curried](https://www.wikiwand.com/en/Currying), so we could have also done this: ```Java - MonadicFunction, Integer> sumOfEvenIncrementsFn = + Fn1, Integer> sumOfEvenIncrementsFn = map((Integer x) -> x + 1) .then(filter(x -> x % 2 == 0)) .then(reduceLeft((x, y) -> x + y)); @@ -95,20 +95,20 @@ What if we want the cross product of a domain and codomain: Let's compose two functions: ```Java - MonadicFunction add = x -> x + 1; - MonadicFunction subtract = x -> x -1; + Fn1 add = x -> x + 1; + Fn1 subtract = x -> x -1; - MonadicFunction noOp = add.then(subtract); + Fn1 noOp = add.then(subtract); // same as - MonadicFunction alsoNoOp = subtract.fmap(add); + Fn1 alsoNoOp = subtract.fmap(add); ``` And partially apply some: ```Java - DyadicFunction add = (x, y) -> x + y; + Fn2 add = (x, y) -> x + y; - MonadicFunction add1 = add.apply(1); + Fn1 add1 = add.apply(1); add1.apply(2); //-> 3 ``` @@ -152,7 +152,7 @@ To address this, tuples in lambda are specializations of `HList`s up to 5 elemen ```Java HNil nil = HList.nil(); - Singleton singleton = nil.cons(5); + SingletonHList singleton = nil.cons(5); Tuple2 tuple2 = singleton.cons(4); Tuple3 tuple3 = tuple2.cons(3); Tuple4 tuple4 = tuple3.cons(2); @@ -165,7 +165,7 @@ To address this, tuples in lambda are specializations of `HList`s up to 5 elemen Additionally, `HList` provides convenience static factory methods for directly constructing lists of up to 5 elements: ```Java - Singleton singleton = HList.singleton(1); + SingletonHList singleton = HList.singletonHList(1); Tuple2 tuple2 = HList.tuple(1, 2); Tuple3 tuple3 = HList.tuple(1, 2, 3); Tuple4 tuple4 = HList.tuple(1, 2, 3, 4); diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java index aa4367a6d..e6481194b 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/Either.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/Either.java @@ -1,7 +1,7 @@ package com.jnape.palatable.lambda.adt; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.functions.specialized.checked.CheckedSupplier; import com.jnape.palatable.lambda.functor.Bifunctor; import com.jnape.palatable.lambda.functor.Functor; @@ -11,7 +11,7 @@ import java.util.function.Consumer; import java.util.function.Supplier; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; /** * The binary tagged union. General semantics tend to connote "success" values via the right value and "failure" values @@ -30,37 +30,37 @@ public final R or(R defaultValue) { return recover(l -> defaultValue); } - public final R recover(MonadicFunction recoveryFn) { + public final R recover(Fn1 recoveryFn) { return match(recoveryFn, id()); } - public final L forfeit(MonadicFunction forfeitFn) { + public final L forfeit(Fn1 forfeitFn) { return match(id(), forfeitFn); } public final R orThrow( - MonadicFunction throwableFn) throws E { + Fn1 throwableFn) throws E { return match(l -> { throw throwableFn.apply(l); }, id()); } - public final Either filter(MonadicFunction pred, + public final Either filter(Fn1 pred, Supplier leftSupplier) { return flatMap(r -> pred.apply(r) ? right(r) : left(leftSupplier.get())); } - public final Either flatMap(MonadicFunction> rightFn) { + public final Either flatMap(Fn1> rightFn) { return flatMap(Either::left, rightFn); } - public final Either flatMap(MonadicFunction> leftFn, - MonadicFunction> rightFn) { + public final Either flatMap(Fn1> leftFn, + Fn1> rightFn) { return match(leftFn, rightFn); } - public final Either merge(DyadicFunction leftFn, - DyadicFunction rightFn, + public final Either merge(Fn2 leftFn, + Fn2 rightFn, Either other) { return this.match( l1 -> other.match(l2 -> left(leftFn.apply(l1, l2)), r -> left(l1)), @@ -82,29 +82,29 @@ public Either peek(Consumer leftConsumer, Consumer rightConsumer) { }); } - public abstract V match(MonadicFunction leftFn, - MonadicFunction rightFn); + public abstract V match(Fn1 leftFn, + Fn1 rightFn); @Override - public final Either fmap(MonadicFunction fn) { + public final Either fmap(Fn1 fn) { return biMapR(fn); } @Override @SuppressWarnings("unchecked") - public final Either biMapL(MonadicFunction fn) { + public final Either biMapL(Fn1 fn) { return (Either) Bifunctor.super.biMapL(fn); } @Override @SuppressWarnings("unchecked") - public final Either biMapR(MonadicFunction fn) { + public final Either biMapR(Fn1 fn) { return (Either) Bifunctor.super.biMapR(fn); } @Override - public final Either biMap(MonadicFunction leftFn, - MonadicFunction rightFn) { + public final Either biMap(Fn1 leftFn, + Fn1 rightFn) { return match(l -> left(leftFn.apply(l)), r -> right(rightFn.apply(r))); } @@ -115,7 +115,7 @@ public static Either fromOptional(Optional optional, Supplier @SuppressWarnings("unchecked") public static Either trying(CheckedSupplier supplier, - MonadicFunction leftFn) { + Fn1 leftFn) { try { return right(supplier.get()); } catch (Exception e) { @@ -143,8 +143,8 @@ private Left(L l) { } @Override - public V match(MonadicFunction leftFn, - MonadicFunction rightFn) { + public V match(Fn1 leftFn, + Fn1 rightFn) { return leftFn.apply(l); } @@ -174,8 +174,8 @@ private Right(R r) { } @Override - public V match(MonadicFunction leftFn, - MonadicFunction rightFn) { + public V match(Fn1 leftFn, + Fn1 rightFn) { return rightFn.apply(r); } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java index fc6e66ee5..cfa575ea6 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java @@ -2,7 +2,7 @@ import com.jnape.palatable.lambda.adt.hlist.HList.HCons; import com.jnape.palatable.lambda.adt.hlist.HList.HNil; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Functor; /** @@ -27,7 +27,7 @@ public <_0> Tuple2<_0, _1> cons(_0 _0) { } @Override - public <_1Prime> Singleton<_1Prime> fmap(MonadicFunction fn) { + public <_1Prime> Singleton<_1Prime> fmap(Fn1 fn) { return new Singleton<>(fn.apply(head())); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java index 35001f291..f57541d0b 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java @@ -1,7 +1,7 @@ package com.jnape.palatable.lambda.adt.hlist; import com.jnape.palatable.lambda.adt.hlist.HList.HCons; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Bifunctor; import com.jnape.palatable.lambda.functor.Functor; @@ -53,25 +53,25 @@ public _2 setValue(_2 value) { } @Override - public <_2Prime> Tuple2<_1, _2Prime> fmap(MonadicFunction fn) { + public <_2Prime> Tuple2<_1, _2Prime> fmap(Fn1 fn) { return tuple(_1(), fn.apply(_2())); } @Override @SuppressWarnings("unchecked") - public <_1Prime> Tuple2<_1Prime, _2> biMapL(MonadicFunction fn) { + public <_1Prime> Tuple2<_1Prime, _2> biMapL(Fn1 fn) { return (Tuple2<_1Prime, _2>) Bifunctor.super.biMapL(fn); } @Override @SuppressWarnings("unchecked") - public <_2Prime> Tuple2<_1, _2Prime> biMapR(MonadicFunction fn) { + public <_2Prime> Tuple2<_1, _2Prime> biMapR(Fn1 fn) { return (Tuple2<_1, _2Prime>) Bifunctor.super.biMapR(fn); } @Override - public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(MonadicFunction lFn, - MonadicFunction rFn) { + public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(Fn1 lFn, + Fn1 rFn) { return new Tuple2<>(lFn.apply(_1()), tail().fmap(rFn)); } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java index 45c711b1d..449013243 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java @@ -1,7 +1,7 @@ package com.jnape.palatable.lambda.adt.hlist; import com.jnape.palatable.lambda.adt.hlist.HList.HCons; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Bifunctor; import com.jnape.palatable.lambda.functor.Functor; @@ -40,25 +40,25 @@ public _3 _3() { } @Override - public <_3Prime> Tuple3<_1, _2, _3Prime> fmap(MonadicFunction fn) { + public <_3Prime> Tuple3<_1, _2, _3Prime> fmap(Fn1 fn) { return biMapR(fn); } @Override @SuppressWarnings("unchecked") - public <_2Prime> Tuple3<_1, _2Prime, _3> biMapL(MonadicFunction fn) { + public <_2Prime> Tuple3<_1, _2Prime, _3> biMapL(Fn1 fn) { return (Tuple3<_1, _2Prime, _3>) Bifunctor.super.biMapL(fn); } @Override @SuppressWarnings("unchecked") - public <_3Prime> Tuple3<_1, _2, _3Prime> biMapR(MonadicFunction fn) { + public <_3Prime> Tuple3<_1, _2, _3Prime> biMapR(Fn1 fn) { return (Tuple3<_1, _2, _3Prime>) Bifunctor.super.biMapR(fn); } @Override - public <_2Prime, _3Prime> Tuple3<_1, _2Prime, _3Prime> biMap(MonadicFunction lFn, - MonadicFunction rFn) { + public <_2Prime, _3Prime> Tuple3<_1, _2Prime, _3Prime> biMap(Fn1 lFn, + Fn1 rFn) { return new Tuple3<>(_1(), tail().biMap(lFn, rFn)); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java index 1e655389f..04416e534 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java @@ -1,7 +1,7 @@ package com.jnape.palatable.lambda.adt.hlist; import com.jnape.palatable.lambda.adt.hlist.HList.HCons; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Bifunctor; import com.jnape.palatable.lambda.functor.Functor; @@ -45,25 +45,25 @@ public _4 _4() { } @Override - public <_4Prime> Tuple4<_1, _2, _3, _4Prime> fmap(MonadicFunction fn) { + public <_4Prime> Tuple4<_1, _2, _3, _4Prime> fmap(Fn1 fn) { return biMapR(fn); } @Override @SuppressWarnings("unchecked") - public <_3Prime> Tuple4<_1, _2, _3Prime, _4> biMapL(MonadicFunction fn) { + public <_3Prime> Tuple4<_1, _2, _3Prime, _4> biMapL(Fn1 fn) { return (Tuple4<_1, _2, _3Prime, _4>) Bifunctor.super.biMapL(fn); } @Override @SuppressWarnings("unchecked") - public <_4Prime> Tuple4<_1, _2, _3, _4Prime> biMapR(MonadicFunction fn) { + public <_4Prime> Tuple4<_1, _2, _3, _4Prime> biMapR(Fn1 fn) { return (Tuple4<_1, _2, _3, _4Prime>) Bifunctor.super.biMapR(fn); } @Override - public <_3Prime, _4Prime> Tuple4<_1, _2, _3Prime, _4Prime> biMap(MonadicFunction lFn, - MonadicFunction rFn) { + public <_3Prime, _4Prime> Tuple4<_1, _2, _3Prime, _4Prime> biMap(Fn1 lFn, + Fn1 rFn) { return new Tuple4<>(_1(), tail().biMap(lFn, rFn)); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java index ead0b387f..1bc4bfa5c 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java @@ -1,7 +1,7 @@ package com.jnape.palatable.lambda.adt.hlist; import com.jnape.palatable.lambda.adt.hlist.HList.HCons; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Bifunctor; import com.jnape.palatable.lambda.functor.Functor; @@ -50,26 +50,26 @@ public _5 _5() { } @Override - public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> fmap(MonadicFunction fn) { + public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> fmap(Fn1 fn) { return biMapR(fn); } @Override @SuppressWarnings("unchecked") - public <_4Prime> Tuple5<_1, _2, _3, _4Prime, _5> biMapL(MonadicFunction fn) { + public <_4Prime> Tuple5<_1, _2, _3, _4Prime, _5> biMapL(Fn1 fn) { return (Tuple5<_1, _2, _3, _4Prime, _5>) Bifunctor.super.biMapL(fn); } @Override @SuppressWarnings("unchecked") - public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> biMapR(MonadicFunction fn) { + public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> biMapR(Fn1 fn) { return (Tuple5<_1, _2, _3, _4, _5Prime>) Bifunctor.super.biMapR(fn); } @Override public <_4Prime, _5Prime> Tuple5<_1, _2, _3, _4Prime, _5Prime> biMap( - MonadicFunction lFn, - MonadicFunction rFn) { + Fn1 lFn, + Fn1 rFn) { return new Tuple5<>(_1(), tail().biMap(lFn, rFn)); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java b/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java index 537f61dc5..aa6471905 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java @@ -10,7 +10,7 @@ import java.util.Optional; import java.util.function.Consumer; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Map.map; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java new file mode 100644 index 000000000..766d57788 --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java @@ -0,0 +1,53 @@ +package com.jnape.palatable.lambda.functions; + +import com.jnape.palatable.lambda.functor.Functor; +import com.jnape.palatable.lambda.functor.Profunctor; + +import java.util.function.Function; + +/** + * A function taking a single argument. This is the core function type that all other function types extend and + * auto-curry with. + * + * @param The input type + * @param The output type + */ +@FunctionalInterface +public interface Fn1 extends Functor, Profunctor, Function { + + B apply(A a); + + default Fn1 then(Fn1 g) { + return fmap(g); + } + + @Override + default Fn1 fmap(Fn1 g) { + return a -> g.apply(apply(a)); + } + + @Override + default Fn1 diMapL(Fn1 fn) { + return (Fn1) Profunctor.super.diMapL(fn); + } + + @Override + default Fn1 diMapR(Fn1 fn) { + return (Fn1) Profunctor.super.diMapR(fn); + } + + @Override + default Fn1 diMap(Fn1 lFn, Fn1 rFn) { + return lFn.andThen(this).andThen(rFn); + } + + @Override + default Fn1 compose(Function before) { + return z -> apply(before.apply(z)); + } + + @Override + default Fn1 andThen(Function after) { + return a -> after.apply(apply(a)); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java similarity index 58% rename from src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java rename to src/main/java/com/jnape/palatable/lambda/functions/Fn2.java index 197f264e1..58a0c6590 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/DyadicFunction.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java @@ -8,24 +8,24 @@ * @param The first argument type * @param The second argument type * @param The return type - * @see MonadicFunction - * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Partial2 + * @see Fn1 + * @see com.jnape.palatable.lambda.functions.builtin.fn2.Partial2 */ @FunctionalInterface -public interface DyadicFunction extends MonadicFunction> { +public interface Fn2 extends Fn1> { C apply(A a, B b); @Override - default MonadicFunction apply(A a) { + default Fn1 apply(A a) { return (b) -> apply(a, b); } - default DyadicFunction flip() { + default Fn2 flip() { return (b, a) -> apply(a, b); } - default MonadicFunction, C> uncurry() { + default Fn1, C> uncurry() { return (ab) -> apply(ab._1(), ab._2()); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/TriadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java similarity index 55% rename from src/main/java/com/jnape/palatable/lambda/functions/TriadicFunction.java rename to src/main/java/com/jnape/palatable/lambda/functions/Fn3.java index 72423cead..91cd087d1 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/TriadicFunction.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java @@ -3,37 +3,37 @@ import com.jnape.palatable.lambda.adt.hlist.Tuple2; /** - * A function taking three arguments. Auto-curried + * A function taking three arguments. Auto-curried. * * @param The first argument type * @param The second argument type * @param The third argument type * @param The return type - * @see DyadicFunction - * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Partial3 + * @see Fn2 + * @see com.jnape.palatable.lambda.functions.builtin.fn2.Partial3 */ @FunctionalInterface -public interface TriadicFunction extends DyadicFunction> { +public interface Fn3 extends Fn2> { D apply(A a, B b, C c); @Override - default DyadicFunction apply(A a) { + default Fn2 apply(A a) { return (b, c) -> apply(a, b, c); } @Override - default MonadicFunction apply(A a, B b) { + default Fn1 apply(A a, B b) { return (c) -> apply(a, b, c); } @Override - default TriadicFunction flip() { + default Fn3 flip() { return (b, a, c) -> apply(a, b, c); } @Override - default DyadicFunction, C, D> uncurry() { + default Fn2, C, D> uncurry() { return (ab, c) -> apply(ab._1(), ab._2(), c); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java deleted file mode 100644 index 18f505acd..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/MonadicFunction.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.jnape.palatable.lambda.functions; - -import com.jnape.palatable.lambda.functor.Functor; -import com.jnape.palatable.lambda.functor.Profunctor; - -import java.util.function.Function; - -/** - * A function taking a single argument. This is the core function type that all other function types extend and - * auto-curry with. - * - * @param The input type - * @param The output type - */ -@FunctionalInterface -public interface MonadicFunction extends Functor, Profunctor, Function { - - B apply(A a); - - default MonadicFunction then(MonadicFunction g) { - return fmap(g); - } - - @Override - default MonadicFunction fmap(MonadicFunction g) { - return a -> g.apply(apply(a)); - } - - @Override - default MonadicFunction diMapL(MonadicFunction fn) { - return (MonadicFunction) Profunctor.super.diMapL(fn); - } - - @Override - default MonadicFunction diMapR(MonadicFunction fn) { - return (MonadicFunction) Profunctor.super.diMapR(fn); - } - - @Override - default MonadicFunction diMap(MonadicFunction lFn, MonadicFunction rFn) { - return lFn.andThen(this).andThen(rFn); - } - - @Override - default MonadicFunction compose(Function before) { - return z -> apply(before.apply(z)); - } - - @Override - default MonadicFunction andThen(Function after) { - return a -> after.apply(apply(a)); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java deleted file mode 100644 index 47e77e3b8..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Map.java +++ /dev/null @@ -1,36 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; -import com.jnape.palatable.lambda.iterators.MappingIterator; - -/** - * Lazily apply a function to each element in an Iterable, producing an Iterable of the mapped - * results. - * - * @param A type contravariant to the input Iterable element type - * @param A type covariant to the output Iterable element type - */ -public final class Map implements DyadicFunction, Iterable, Iterable> { - - private Map() { - } - - @Override - public Iterable apply(MonadicFunction function, Iterable as) { - return () -> new MappingIterator<>(function, as.iterator()); - } - - public static Map map() { - return new Map<>(); - } - - public static MonadicFunction, Iterable> map( - MonadicFunction function) { - return Map.map().apply(function); - } - - public static Iterable map(MonadicFunction function, Iterable as) { - return Map.map(function).apply(as); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java deleted file mode 100644 index 2990dac51..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2.java +++ /dev/null @@ -1,36 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; - -/** - * Partially apply (fix) the first argument of a DyadicFunction, producing a MonadicFunction - * that takes the remaining argument. This is isomorphic to calling {@link com.jnape.palatable.lambda.functions.DyadicFunction#apply(Object)}. - * - * @param The type of the value to be supplied - * @param The input argument type of the resulting function - * @param The return type of the resulting function - * @see Partial3 - */ -public final class Partial2 implements DyadicFunction, A, MonadicFunction> { - - private Partial2() { - } - - @Override - public MonadicFunction apply(DyadicFunction function, A a) { - return function.apply(a); - } - - public static Partial2, A, MonadicFunction> partial2() { - return new Partial2<>(); - } - - public static MonadicFunction> partial2(DyadicFunction function) { - return Partial2.partial2().apply(new Partial2<>(), function); - } - - public static MonadicFunction partial2(DyadicFunction function, A a) { - return partial2(function).apply(a); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java deleted file mode 100644 index cb1423b01..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; -import com.jnape.palatable.lambda.functions.TriadicFunction; - -/** - * Partially apply (fix) the first argument of a TriadicFunction, producing a DyadicFunction - * that takes the remaining two argument. This is isomorphic to calling {@link com.jnape.palatable.lambda.functions.TriadicFunction#apply(Object)}. - * - * @param The type of the value to be supplied - * @param The first input argument type of the resulting function - * @param The second input argument type of the resulting function - * @param The return type of the resulting function - * @see Partial2 - */ -public final class Partial3 implements DyadicFunction, A, DyadicFunction> { - - private Partial3() { - } - - @Override - public DyadicFunction apply(TriadicFunction function, A a) { - return function.apply(a); - } - - public static Partial3 partial3() { - return new Partial3<>(); - } - - public static MonadicFunction> partial3( - TriadicFunction function) { - return Partial3.partial3().apply(function); - } - - public static DyadicFunction partial3(TriadicFunction function, A a) { - return partial3(function).apply(a); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java deleted file mode 100644 index 40615afbb..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeft.java +++ /dev/null @@ -1,52 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; - -import java.util.Iterator; -import java.util.Optional; - -import static com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft.foldLeft; - -/** - * Given an Iterable of As and a {@link DyadicFunction}<A, A, A>, - * iteratively accumulate over the Iterable, returning an Optional<A> (if the - * Iterable is empty, the result is Optional.empty(); otherwise, the result is wrapped in - * Optional.of(). For this reason, null accumulation results are considered erroneous and will - * throw. - *

- * This function is isomorphic to a right fold over the Iterable where the tail element is the starting - * accumulation value and the result is lifted into an Optional. - * - * @param The input Iterable element type, as well as the accumulation type - * @see ReduceLeft - * @see com.jnape.palatable.lambda.functions.builtin.triadic.FoldRight - */ -public final class ReduceRight implements DyadicFunction, Iterable, Optional> { - - private ReduceRight() { - } - - @Override - public final Optional apply(DyadicFunction function, Iterable as) { - return reduceLeft(function.flip(), reverse(as)); - } - - public static ReduceRight reduceRight() { - return new ReduceRight<>(); - } - - public static MonadicFunction, Optional> reduceRight( - DyadicFunction function) { - return ReduceRight.reduceRight().apply(function); - } - - public static Optional reduceRight(DyadicFunction function, - Iterable as) { - return ReduceRight.reduceRight(function).apply(as); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Constantly.java similarity index 64% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Constantly.java index 4e08f87a5..fb034b3fe 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Constantly.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Constantly.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; /** * A function that takes two arguments and always returns the first argument. @@ -9,7 +9,7 @@ * @param The first argument type, and the the function's return type * @param The second (ignored) argument type */ -public final class Constantly implements DyadicFunction { +public final class Constantly implements Fn2 { private Constantly() { } @@ -23,7 +23,7 @@ public static Constantly constantly() { return new Constantly<>(); } - public static MonadicFunction constantly(A a) { + public static Fn1 constantly(A a) { return Constantly.constantly().apply(a); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java similarity index 78% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java index ec6c360ec..8f626dd33 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Cycle.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Cycle.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.iterators.CyclicIterator; import static java.util.Arrays.asList; @@ -11,7 +11,7 @@ * * @param The Iterable element type */ -public final class Cycle implements MonadicFunction, Iterable> { +public final class Cycle implements Fn1, Iterable> { private Cycle() { } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Id.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Id.java similarity index 63% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Id.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Id.java index 5a6d0abb4..7bba0f7f7 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Id.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Id.java @@ -1,13 +1,13 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; /** * The identity function. * * @param The input/output type */ -public final class Id implements MonadicFunction { +public final class Id implements Fn1 { private static final Id ID = new Id(); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java similarity index 73% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java index 30e65ab8e..6e1547155 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Repeat.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Repeat.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.iterators.RepetitiousIterator; /** @@ -8,7 +8,7 @@ * * @param The Iterable element type */ -public final class Repeat implements MonadicFunction> { +public final class Repeat implements Fn1> { private Repeat() { } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java similarity index 76% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java index 311ff5192..51637ce0d 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/monadic/Reverse.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Reverse.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.iterators.ReversingIterator; /** @@ -9,7 +9,7 @@ * * @param The Iterable element type */ -public final class Reverse implements MonadicFunction, Iterable> { +public final class Reverse implements Fn1, Iterable> { private Reverse() { } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java similarity index 52% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java index 75645dfed..d3d96ccb4 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/All.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/All.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; /** * Eagerly apply a predicate to each element in an Iterable, returning true if every element @@ -11,13 +11,13 @@ * @param The input Iterable element type * @see Any */ -public final class All implements DyadicFunction, Iterable, Boolean> { +public final class All implements Fn2, Iterable, Boolean> { private All() { } @Override - public Boolean apply(MonadicFunction predicate, Iterable as) { + public Boolean apply(Fn1 predicate, Iterable as) { for (A a : as) if (!predicate.apply(a)) return false; @@ -29,11 +29,11 @@ public static All all() { return new All<>(); } - public static MonadicFunction, Boolean> all(MonadicFunction predicate) { + public static Fn1, Boolean> all(Fn1 predicate) { return All.all().apply(predicate); } - public static Boolean all(MonadicFunction predicate, Iterable as) { + public static Boolean all(Fn1 predicate, Iterable as) { return All.all(predicate).apply(as); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Any.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java similarity index 52% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Any.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java index 110111adb..37a83bbe6 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Any.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Any.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; /** * Eagerly apply a predicate to each element in an Iterable, returning true if any element @@ -11,13 +11,13 @@ * @param The input Iterable element type * @see All */ -public final class Any implements DyadicFunction, Iterable, Boolean> { +public final class Any implements Fn2, Iterable, Boolean> { private Any() { } @Override - public Boolean apply(MonadicFunction predicate, Iterable as) { + public Boolean apply(Fn1 predicate, Iterable as) { for (A a : as) if (predicate.apply(a)) return true; @@ -29,11 +29,11 @@ public static Any any() { return new Any<>(); } - public static MonadicFunction, Boolean> any(MonadicFunction predicate) { + public static Fn1, Boolean> any(Fn1 predicate) { return Any.any().apply(predicate); } - public static Boolean any(MonadicFunction predicate, Iterable as) { + public static Boolean any(Fn1 predicate, Iterable as) { return Any.any(predicate).apply(as); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProduct.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java similarity index 78% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProduct.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java index 29d2846a6..40da00035 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProduct.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProduct.java @@ -1,8 +1,8 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.CombinatorialIterator; /** @@ -19,7 +19,7 @@ * @param The multiplier Iterable element type * @see Zip */ -public final class CartesianProduct implements DyadicFunction, Iterable, Iterable>> { +public final class CartesianProduct implements Fn2, Iterable, Iterable>> { private CartesianProduct() { } @@ -33,7 +33,7 @@ public static CartesianProduct cartesianProduct() { return new CartesianProduct<>(); } - public static MonadicFunction, Iterable>> cartesianProduct(Iterable as) { + public static Fn1, Iterable>> cartesianProduct(Iterable as) { return CartesianProduct.cartesianProduct().apply(as); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Drop.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java similarity index 71% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Drop.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java index 537fa015e..4a25573d3 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Drop.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Drop.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.DroppingIterator; /** @@ -13,7 +13,7 @@ * @see DropWhile * @see Take */ -public final class Drop implements DyadicFunction, Iterable> { +public final class Drop implements Fn2, Iterable> { private Drop() { } @@ -27,7 +27,7 @@ public static Drop drop() { return new Drop<>(); } - public static MonadicFunction, Iterable> drop(int n) { + public static Fn1, Iterable> drop(int n) { return Drop.drop().apply(n); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java similarity index 53% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhile.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java index 676eef969..59be5363e 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhile.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhile.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.PredicatedDroppingIterator; /** @@ -14,13 +14,13 @@ * @see TakeWhile */ -public final class DropWhile implements DyadicFunction, Iterable, Iterable> { +public final class DropWhile implements Fn2, Iterable, Iterable> { private DropWhile() { } @Override - public Iterable apply(MonadicFunction predicate, Iterable as) { + public Iterable apply(Fn1 predicate, Iterable as) { return () -> new PredicatedDroppingIterator<>(predicate, as.iterator()); } @@ -28,12 +28,11 @@ public static DropWhile dropWhile() { return new DropWhile<>(); } - public static MonadicFunction, Iterable> dropWhile( - MonadicFunction predicate) { + public static Fn1, Iterable> dropWhile(Fn1 predicate) { return DropWhile.dropWhile().apply(predicate); } - public static Iterable dropWhile(MonadicFunction predicate, Iterable as) { + public static Iterable dropWhile(Fn1 predicate, Iterable as) { return DropWhile.dropWhile(predicate).apply(as); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Filter.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java similarity index 55% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Filter.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java index 394faf487..2b6d7c610 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Filter.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Filter.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.FilteringIterator; /** @@ -12,13 +12,13 @@ * @see TakeWhile * @see DropWhile */ -public final class Filter implements DyadicFunction, Iterable, Iterable> { +public final class Filter implements Fn2, Iterable, Iterable> { private Filter() { } @Override - public Iterable apply(MonadicFunction predicate, Iterable as) { + public Iterable apply(Fn1 predicate, Iterable as) { return () -> new FilteringIterator<>(predicate, as.iterator()); } @@ -26,11 +26,11 @@ public static Filter filter() { return new Filter<>(); } - public static MonadicFunction, Iterable> filter(MonadicFunction predicate) { + public static Fn1, Iterable> filter(Fn1 predicate) { return Filter.filter().apply(predicate); } - public static Iterable filter(MonadicFunction predicate, Iterable as) { + public static Iterable filter(Fn1 predicate, Iterable as) { return Filter.filter(predicate).apply(as); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOf.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java similarity index 71% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOf.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java index f2438aead..f990ecab2 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOf.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOf.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.GroupingIterator; /** @@ -12,7 +12,7 @@ * * @param The Iterable element type */ -public final class InGroupsOf implements DyadicFunction, Iterable>> { +public final class InGroupsOf implements Fn2, Iterable>> { private InGroupsOf() { } @@ -26,7 +26,7 @@ public static InGroupsOf inGroupsOf() { return new InGroupsOf<>(); } - public static MonadicFunction, Iterable>> inGroupsOf(Integer k) { + public static Fn1, Iterable>> inGroupsOf(Integer k) { return InGroupsOf.inGroupsOf().apply(k); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Iterate.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java similarity index 60% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Iterate.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java index 3e4330f5f..8a7209567 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Iterate.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Iterate.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.UnfoldingIterator; import java.util.Optional; @@ -15,13 +15,13 @@ * * @param The Iterable element type */ -public final class Iterate implements DyadicFunction, A, Iterable> { +public final class Iterate implements Fn2, A, Iterable> { private Iterate() { } @Override - public Iterable apply(MonadicFunction fn, A seed) { + public Iterable apply(Fn1 fn, A seed) { return () -> new UnfoldingIterator<>(a -> Optional.of(tuple(a, fn.apply(a))), seed); } @@ -29,11 +29,11 @@ public static Iterate iterate() { return new Iterate<>(); } - public static MonadicFunction> iterate(MonadicFunction fn) { + public static Fn1> iterate(Fn1 fn) { return Iterate.iterate().apply(fn); } - public static Iterable iterate(MonadicFunction fn, A seed) { + public static Iterable iterate(Fn1 fn, A seed) { return Iterate.iterate(fn).apply(seed); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java new file mode 100644 index 000000000..3aecce3a5 --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Map.java @@ -0,0 +1,35 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; +import com.jnape.palatable.lambda.iterators.MappingIterator; + +/** + * Lazily apply a function to each element in an Iterable, producing an Iterable of the mapped + * results. + * + * @param A type contravariant to the input Iterable element type + * @param A type covariant to the output Iterable element type + */ +public final class Map implements Fn2, Iterable, Iterable> { + + private Map() { + } + + @Override + public Iterable apply(Fn1 fn, Iterable as) { + return () -> new MappingIterator<>(fn, as.iterator()); + } + + public static Map map() { + return new Map<>(); + } + + public static Fn1, Iterable> map(Fn1 fn) { + return Map.map().apply(fn); + } + + public static Iterable map(Fn1 fn, Iterable as) { + return Map.map(fn).apply(as); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java new file mode 100644 index 000000000..a7292ad93 --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2.java @@ -0,0 +1,36 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; + +/** + * Partially apply (fix) the first argument of a Fn2, producing a Fn1 that takes the remaining + * argument. This is isomorphic to calling {@link Fn2#apply(Object)}. + * + * @param The type of the value to be supplied + * @param The input argument type of the resulting function + * @param The return type of the resulting function + * @see Partial3 + */ +public final class Partial2 implements Fn2, A, Fn1> { + + private Partial2() { + } + + @Override + public Fn1 apply(Fn2 fn, A a) { + return fn.apply(a); + } + + public static Partial2, A, Fn1> partial2() { + return new Partial2<>(); + } + + public static Fn1> partial2(Fn2 fn) { + return Partial2.partial2().apply(new Partial2<>(), fn); + } + + public static Fn1 partial2(Fn2 fn, A a) { + return partial2(fn).apply(a); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.java new file mode 100644 index 000000000..8cf530b6e --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3.java @@ -0,0 +1,38 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; +import com.jnape.palatable.lambda.functions.Fn3; + +/** + * Partially apply (fix) the first argument of a Fn3, producing a Fn2 that takes the remaining + * two argument. This is isomorphic to calling {@link Fn3#apply(Object)}. + * + * @param The type of the value to be supplied + * @param The first input argument type of the resulting function + * @param The second input argument type of the resulting function + * @param The return type of the resulting function + * @see Partial2 + */ +public final class Partial3 implements Fn2, A, Fn2> { + + private Partial3() { + } + + @Override + public Fn2 apply(Fn3 fn, A a) { + return fn.apply(a); + } + + public static Partial3 partial3() { + return new Partial3<>(); + } + + public static Fn1> partial3(Fn3 fn) { + return Partial3.partial3().apply(fn); + } + + public static Fn2 partial3(Fn3 fn, A a) { + return partial3(fn).apply(a); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java new file mode 100644 index 000000000..b493cf5db --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeft.java @@ -0,0 +1,50 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; + +import java.util.Iterator; +import java.util.Optional; + +import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft; + +/** + * Given an Iterable of As and a {@link Fn2}<A, A, A>, iteratively + * accumulate over the Iterable, returning an Optional<A> (if the Iterable + * is empty, the result is Optional.empty(); otherwise, the result is wrapped in + * Optional.of(). For this reason, null accumulation results are considered erroneous and will + * throw. + *

+ * This function is isomorphic to a left fold over the Iterable where the head element is the starting + * accumulation value and the result is lifted into an Optional. + * + * @param The input Iterable element type, as well as the accumulation type + * @see ReduceRight + * @see com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft + */ +public final class ReduceLeft implements Fn2, Iterable, Optional> { + + private ReduceLeft() { + } + + @Override + public Optional apply(Fn2 fn, Iterable as) { + Iterator iterator = as.iterator(); + if (!iterator.hasNext()) + return Optional.empty(); + + return Optional.of(foldLeft(fn, iterator.next(), () -> iterator)); + } + + public static ReduceLeft reduceLeft() { + return new ReduceLeft<>(); + } + + public static Fn1, Optional> reduceLeft(Fn2 fn) { + return ReduceLeft.reduceLeft().apply(fn); + } + + public static Optional reduceLeft(Fn2 fn, Iterable as) { + return ReduceLeft.reduceLeft(fn).apply(as); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java new file mode 100644 index 000000000..1a49359cf --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRight.java @@ -0,0 +1,46 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; + +import java.util.Optional; + +import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse; +import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceLeft.reduceLeft; + +/** + * Given an Iterable of As and a {@link Fn2}<A, A, A>, iteratively + * accumulate over the Iterable, returning an Optional<A> (if the Iterable + * is empty, the result is Optional.empty(); otherwise, the result is wrapped in + * Optional.of(). For this reason, null accumulation results are considered erroneous and will + * throw. + *

+ * This function is isomorphic to a right fold over the Iterable where the tail element is the starting + * accumulation value and the result is lifted into an Optional. + * + * @param The input Iterable element type, as well as the accumulation type + * @see ReduceLeft + * @see com.jnape.palatable.lambda.functions.builtin.fn3.FoldRight + */ +public final class ReduceRight implements Fn2, Iterable, Optional> { + + private ReduceRight() { + } + + @Override + public final Optional apply(Fn2 fn, Iterable as) { + return reduceLeft(fn.flip(), reverse(as)); + } + + public static ReduceRight reduceRight() { + return new ReduceRight<>(); + } + + public static Fn1, Optional> reduceRight(Fn2 fn) { + return ReduceRight.reduceRight().apply(fn); + } + + public static Optional reduceRight(Fn2 fn, Iterable as) { + return ReduceRight.reduceRight(fn).apply(as); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Take.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java similarity index 69% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Take.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java index c0b860ca1..2d095724c 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Take.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Take.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.TakingIterator; /** @@ -13,7 +13,7 @@ * @see TakeWhile * @see Drop */ -public final class Take implements DyadicFunction, Iterable> { +public final class Take implements Fn2, Iterable> { private Take() { } @@ -27,7 +27,7 @@ public static Take take() { return new Take<>(); } - public static MonadicFunction, Iterable> take(int n) { + public static Fn1, Iterable> take(int n) { return Take.take().apply(n); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhile.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java similarity index 53% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhile.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java index 335983e6e..8cec722e5 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhile.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhile.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.PredicatedTakingIterator; /** @@ -13,13 +13,13 @@ * @see Filter * @see DropWhile */ -public final class TakeWhile implements DyadicFunction, Iterable, Iterable> { +public final class TakeWhile implements Fn2, Iterable, Iterable> { private TakeWhile() { } @Override - public Iterable apply(MonadicFunction predicate, Iterable as) { + public Iterable apply(Fn1 predicate, Iterable as) { return () -> new PredicatedTakingIterator<>(predicate, as.iterator()); } @@ -27,12 +27,12 @@ public static TakeWhile takeWhile() { return new TakeWhile<>(); } - public static MonadicFunction, Iterable> takeWhile( - MonadicFunction predicate) { + public static Fn1, Iterable> takeWhile( + Fn1 predicate) { return TakeWhile.takeWhile().apply(predicate); } - public static Iterable takeWhile(MonadicFunction predicate, Iterable as) { + public static Iterable takeWhile(Fn1 predicate, Iterable as) { return TakeWhile.takeWhile(predicate).apply(as); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2.java similarity index 70% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2.java index 21a015ee8..aed51e164 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2.java @@ -1,8 +1,8 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; @@ -13,7 +13,7 @@ * @param The type of the second value; also the second slot type of returned Tuple2 * @see com.jnape.palatable.lambda.adt.hlist.Tuple2 */ -public final class Tupler2 implements DyadicFunction> { +public final class Tupler2 implements Fn2> { private Tupler2() { } @@ -27,7 +27,7 @@ public static Tupler2 tupler() { return new Tupler2<>(); } - public static MonadicFunction> tupler(A a) { + public static Fn1> tupler(A a) { return Tupler2.tupler().apply(a); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Unfoldr.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java similarity index 61% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Unfoldr.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java index 0a1e311a8..6befaf292 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Unfoldr.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Unfoldr.java @@ -1,8 +1,8 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.lambda.iterators.UnfoldingIterator; import java.util.Optional; @@ -28,25 +28,25 @@ * @param The output Iterable element type * @param The unfolding function input type */ -public final class Unfoldr implements DyadicFunction>>, B, Iterable> { +public final class Unfoldr implements Fn2>>, B, Iterable> { private Unfoldr() { } @Override - public Iterable apply(MonadicFunction>> function, B b) { - return () -> new UnfoldingIterator<>(function, b); + public Iterable apply(Fn1>> fn, B b) { + return () -> new UnfoldingIterator<>(fn, b); } public static Unfoldr unfoldr() { return new Unfoldr<>(); } - public static MonadicFunction> unfoldr(MonadicFunction>> function) { - return Unfoldr.unfoldr().apply(function); + public static Fn1> unfoldr(Fn1>> fn) { + return Unfoldr.unfoldr().apply(fn); } - public static Iterable unfoldr(MonadicFunction>> function, B b) { - return unfoldr(function).apply(b); + public static Iterable unfoldr(Fn1>> fn, B b) { + return unfoldr(fn).apply(b); } } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Zip.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java similarity index 61% rename from src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Zip.java rename to src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java index e985fd7f9..1cc8838ca 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Zip.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Zip.java @@ -1,11 +1,11 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Tupler2.tupler; -import static com.jnape.palatable.lambda.functions.builtin.triadic.ZipWith.zipWith; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Tupler2.tupler; +import static com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith.zipWith; /** * Zip together two Iterables into a single Iterable of Tuple2<A, B>. If @@ -14,9 +14,9 @@ * * @param The first input Iterable element type, and the type of the first tuple slot in the output Iterable * @param The second input Iterable element type, and the type of the second tuple slot in the output Iterable - * @see com.jnape.palatable.lambda.functions.builtin.triadic.ZipWith + * @see com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith */ -public final class Zip implements DyadicFunction, Iterable, Iterable>> { +public final class Zip implements Fn2, Iterable, Iterable>> { private Zip() { } @@ -30,7 +30,7 @@ public static Zip zip() { return new Zip<>(); } - public static MonadicFunction, Iterable>> zip(Iterable as) { + public static Fn1, Iterable>> zip(Iterable as) { return Zip.zip().apply(as); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java new file mode 100644 index 000000000..97f5a658c --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeft.java @@ -0,0 +1,49 @@ +package com.jnape.palatable.lambda.functions.builtin.fn3; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; +import com.jnape.palatable.lambda.functions.Fn3; + +/** + * Given an Iterable of As, a starting value B, and a {@link Fn2}<B, A, + * B>, iteratively accumulate over the Iterable, ultimately returning a final B + * value. If the Iterable is empty, just return the starting B value. Note that, as the name + * implies, this function accumulates from left to right, such that foldLeft(f, 0, asList(1, 2, 3, 4, 5)) + * is evaluated as f(f(f(f(f(0, 1), 2), 3), 4), 5). + *

+ * For more information, read about Catamorphisms. + * + * @param The Iterable element type + * @param The accumulation type + * @see FoldRight + */ +public final class FoldLeft implements Fn3, B, Iterable, B> { + + private FoldLeft() { + } + + @Override + public B apply(Fn2 fn, B acc, Iterable as) { + B accumulation = acc; + for (A a : as) + accumulation = fn.apply(accumulation, a); + return accumulation; + } + + public static FoldLeft foldLeft() { + return new FoldLeft<>(); + } + + public static Fn2, B> foldLeft(Fn2 fn) { + return FoldLeft.foldLeft().apply(fn); + } + + public static Fn1, B> foldLeft(Fn2 fn, B acc) { + return FoldLeft.foldLeft(fn).apply(acc); + } + + public static B foldLeft(Fn2 fn, B acc, Iterable as) { + return FoldLeft.foldLeft(fn, acc).apply(as); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java new file mode 100644 index 000000000..c5717a50d --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRight.java @@ -0,0 +1,49 @@ +package com.jnape.palatable.lambda.functions.builtin.fn3; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; +import com.jnape.palatable.lambda.functions.Fn3; + +import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse; +import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft; + +/** + * Given an Iterable of As, a starting value B, and a {@link Fn2}<A, B, + * B>, iteratively accumulate over the Iterable, ultimately returning a final B + * value. If the Iterable is empty, just return the starting B value. This function is the + * iterative inverse of {@link FoldLeft}, such that foldRight(f, 0, asList(1, 2, 3, 4, 5)) is evaluated as + * f(f(f(f(f(0, 5), 4), 3), 2), 1). + *

+ * For more information, read about Catamorphisms. + * + * @param The Iterable element type + * @param The accumulation type + * @see FoldLeft + */ +public final class FoldRight implements Fn3, B, Iterable, B> { + + private FoldRight() { + } + + @Override + public B apply(Fn2 fn, B acc, Iterable as) { + return foldLeft(fn.flip(), acc, reverse(as)); + } + + public static FoldRight foldRight() { + return new FoldRight<>(); + } + + public static Fn2, B> foldRight(Fn2 fn) { + return FoldRight.foldRight().apply(fn); + } + + public static Fn1, B> foldRight(Fn2 fn, B acc) { + return FoldRight.foldRight(fn).apply(acc); + } + + public static B foldRight(Fn2 fn, B acc, Iterable as) { + return FoldRight.foldRight(fn, acc).apply(as); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java new file mode 100644 index 000000000..84a513223 --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeft.java @@ -0,0 +1,44 @@ +package com.jnape.palatable.lambda.functions.builtin.fn3; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; +import com.jnape.palatable.lambda.functions.Fn3; +import com.jnape.palatable.lambda.iterators.ScanningIterator; + +/** + * Given an Iterable of As, a starting value B, and a {@link Fn2}<B, A, + * B>, iteratively accumulate over the Iterable, collecting each function application result, + * finally returning an Iterable of all the results. Note that, as the name implies, this function + * accumulates from left to right, such that scanLeft(f, 0, asList(1,2,3,4,5)) is evaluated as 0, f(0, 1), + * f(f(0, 1), 2), f(f(f(0, 1), 2), 3), f(f(f(f(0, 1), 2), 3), 4), f(f(f(f(f(0, 1), 2), 3), 4), 5). + * + * @param The Iterable element type + * @param The accumulation type + * @see FoldLeft + */ +public final class ScanLeft implements Fn3, B, Iterable, Iterable> { + + private ScanLeft() { + } + + @Override + public Iterable apply(Fn2 fn, B b, Iterable as) { + return () -> new ScanningIterator<>(fn, b, as.iterator()); + } + + public static ScanLeft scanLeft() { + return new ScanLeft<>(); + } + + public static Fn2, Iterable> scanLeft(Fn2 fn) { + return ScanLeft.scanLeft().apply(fn); + } + + public static Fn1, Iterable> scanLeft(Fn2 fn, B b) { + return ScanLeft.scanLeft(fn).apply(b); + } + + public static Iterable scanLeft(Fn2 fn, B b, Iterable as) { + return ScanLeft.scanLeft(fn, b).apply(as); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java new file mode 100644 index 000000000..eb5ea480b --- /dev/null +++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWith.java @@ -0,0 +1,46 @@ +package com.jnape.palatable.lambda.functions.builtin.fn3; + +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; +import com.jnape.palatable.lambda.functions.Fn3; +import com.jnape.palatable.lambda.iterators.ZippingIterator; + +/** + * Zip together two Iterables by applying a zipping function to the successive elements of each + * Iterable until one of them runs out of elements. Returns an Iterable containing the + * results. + * + * @param The first input Iterable element type + * @param The second input Iterable element type + * @param The output Iterable element type + * @see com.jnape.palatable.lambda.functions.builtin.fn2.Zip + */ +public final class ZipWith implements Fn3, Iterable, Iterable, Iterable> { + + private ZipWith() { + } + + @Override + public Iterable apply(Fn2 zipper, Iterable as, Iterable bs) { + return () -> new ZippingIterator<>(zipper, as.iterator(), bs.iterator()); + } + + public static ZipWith zipWith() { + return new ZipWith<>(); + } + + public static Fn2, Iterable, Iterable> zipWith( + Fn2 zipper) { + return ZipWith.zipWith().apply(zipper); + } + + public static Fn1, Iterable> zipWith(Fn2 zipper, + Iterable as) { + return ZipWith.zipWith(zipper).apply(as); + } + + public static Iterable zipWith(Fn2 zipper, Iterable as, + Iterable bs) { + return ZipWith.zipWith(zipper, as).apply(bs); + } +} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java deleted file mode 100644 index 03b9b7ad5..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeft.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; -import com.jnape.palatable.lambda.functions.TriadicFunction; - -/** - * Given an Iterable of As, a starting value B, and a {@link - * DyadicFunction}<B, A, B>, iteratively accumulate over the Iterable, ultimately returning a - * final B value. If the Iterable is empty, just return the starting B value. - * Note that, as the name implies, this function accumulates from left to right, such that foldLeft(f, 0, - * asList(1, 2, 3, 4, 5)) is evaluated as f(f(f(f(f(0, 1), 2), 3), 4), 5). - *

- * For more information, read about Catamorphisms. - * - * @param The Iterable element type - * @param The accumulation type - * @see FoldRight - */ -public final class FoldLeft implements TriadicFunction, B, Iterable, B> { - - private FoldLeft() { - } - - @Override - public B apply(DyadicFunction function, B initialAccumulation, - Iterable as) { - B accumulation = initialAccumulation; - for (A a : as) - accumulation = function.apply(accumulation, a); - return accumulation; - } - - public static FoldLeft foldLeft() { - return new FoldLeft<>(); - } - - public static DyadicFunction, B> foldLeft( - DyadicFunction function) { - return FoldLeft.foldLeft().apply(function); - } - - public static MonadicFunction, B> foldLeft( - DyadicFunction function, B initialAccumulation) { - return FoldLeft.foldLeft(function).apply(initialAccumulation); - } - - public static B foldLeft(DyadicFunction function, B initialAccumulation, - Iterable as) { - return FoldLeft.foldLeft(function, initialAccumulation).apply(as); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java deleted file mode 100644 index 8d7f472c6..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRight.java +++ /dev/null @@ -1,52 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; -import com.jnape.palatable.lambda.functions.TriadicFunction; - -import static com.jnape.palatable.lambda.functions.builtin.monadic.Reverse.reverse; -import static com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft.foldLeft; - -/** - * Given an Iterable of As, a starting value B, and a {@link - * DyadicFunction}<A, B, B>, iteratively accumulate over the Iterable, ultimately returning a - * final B value. If the Iterable is empty, just return the starting B value. - * This function is the iterative inverse of {@link FoldLeft}, such that foldRight(f, 0, asList(1, 2, 3, 4, - * 5)) is evaluated as f(f(f(f(f(0, 5), 4), 3), 2), 1). - *

- * For more information, read about Catamorphisms. - * - * @param The Iterable element type - * @param The accumulation type - * @see FoldLeft - */ -public final class FoldRight implements TriadicFunction, B, Iterable, B> { - - private FoldRight() { - } - - @Override - public B apply(DyadicFunction function, B initialAccumulation, Iterable as) { - return foldLeft(function.flip(), initialAccumulation, reverse(as)); - } - - public static FoldRight foldRight() { - return new FoldRight<>(); - } - - public static DyadicFunction, B> foldRight( - DyadicFunction function) { - return FoldRight.foldRight().apply(function); - } - - public static MonadicFunction, B> foldRight( - DyadicFunction function, B initialAccumulation) { - return FoldRight.foldRight(function).apply(initialAccumulation); - } - - public static B foldRight(DyadicFunction function, B initialAccumulation, - Iterable as) { - return FoldRight.foldRight(function, initialAccumulation).apply(as); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java deleted file mode 100644 index daf727e18..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeft.java +++ /dev/null @@ -1,54 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; -import com.jnape.palatable.lambda.functions.TriadicFunction; -import com.jnape.palatable.lambda.iterators.ScanningIterator; - -import static java.util.Arrays.asList; - -/** - * Given an Iterable of As, a starting value B, and a {@link - * DyadicFunction}<B, A, B>, iteratively accumulate over the Iterable, collecting each - * function application result, finally returning an Iterable of all the results. Note that, as the name - * implies, this function accumulates from left to right, such that scanLeft(f, 0, asList(1,2,3,4,5)) is - * evaluated as 0, f(0, 1), f(f(0, 1), 2), f(f(f(0, 1), 2), 3), f(f(f(f(0, 1), 2), 3), 4), f(f(f(f(f(0, 1), 2), 3), 4), - * 5). - * - * @param The Iterable element type - * @param The accumulation type - * @see FoldLeft - */ -public final class ScanLeft implements TriadicFunction, B, Iterable, Iterable> { - - private ScanLeft() { - } - - @Override - public Iterable apply(DyadicFunction fn, B b, Iterable as) { - return () -> new ScanningIterator<>(fn, b, as.iterator()); - } - - public static ScanLeft scanLeft() { - return new ScanLeft<>(); - } - - public static DyadicFunction, Iterable> scanLeft( - DyadicFunction fn) { - return ScanLeft.scanLeft().apply(fn); - } - - public static MonadicFunction, Iterable> scanLeft( - DyadicFunction fn, B b) { - return ScanLeft.scanLeft(fn).apply(b); - } - - public static Iterable scanLeft(DyadicFunction fn, B b, - Iterable as) { - return ScanLeft.scanLeft(fn, b).apply(as); - } - - public static void main(String[] args) { - scanLeft((acc, x) -> "f(" + acc + ", " + x + ")", "0", asList(1, 2, 3, 4, 5)).forEach(System.out::println); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java deleted file mode 100644 index 9f2687296..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWith.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; -import com.jnape.palatable.lambda.functions.TriadicFunction; -import com.jnape.palatable.lambda.iterators.ZippingIterator; - -/** - * Zip together two Iterables by applying a zipping function to the successive elements of each - * Iterable until one of them runs out of elements. Returns an Iterable containing the - * results. - * - * @param The first input Iterable element type - * @param The second input Iterable element type - * @param The output Iterable element type - * @see com.jnape.palatable.lambda.functions.builtin.dyadic.Zip - */ -public final class ZipWith implements TriadicFunction, Iterable, Iterable, Iterable> { - - private ZipWith() { - } - - @Override - public Iterable apply(DyadicFunction zipper, Iterable as, Iterable bs) { - return () -> new ZippingIterator<>(zipper, as.iterator(), bs.iterator()); - } - - public static ZipWith zipWith() { - return new ZipWith<>(); - } - - public static DyadicFunction, Iterable, Iterable> zipWith( - DyadicFunction zipper) { - return ZipWith.zipWith().apply(zipper); - } - - public static MonadicFunction, Iterable> zipWith( - DyadicFunction zipper, Iterable as) { - return ZipWith.zipWith(zipper).apply(as); - } - - public static Iterable zipWith(DyadicFunction zipper, - Iterable as, Iterable bs) { - return ZipWith.zipWith(zipper, as).apply(bs); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java index 5b3095972..8f7a0e427 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java @@ -1,13 +1,13 @@ package com.jnape.palatable.lambda.functions.specialized; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; /** - * A specialized {@link MonadicFunction} that returns a Boolean. + * A specialized {@link Fn1} that returns a Boolean. * * @param The argument type */ -public interface Predicate extends MonadicFunction, java.util.function.Predicate { +public interface Predicate extends Fn1, java.util.function.Predicate { @Override default boolean test(A a) { diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedMonadicFunction.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java similarity index 67% rename from src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedMonadicFunction.java rename to src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java index c5013e4ad..2593bf205 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedMonadicFunction.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java @@ -1,19 +1,19 @@ package com.jnape.palatable.lambda.functions.specialized.checked; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import static com.jnape.palatable.lambda.functions.specialized.checked.Runtime.throwChecked; /** - * Specialized {@link MonadicFunction} that can throw checked exceptions. + * Specialized {@link Fn1} that can throw checked exceptions. * * @param The input type * @param The output type * @see CheckedSupplier - * @see MonadicFunction + * @see Fn1 */ @FunctionalInterface -public interface CheckedMonadicFunction extends MonadicFunction { +public interface CheckedFn1 extends Fn1 { @Override default B apply(A a) { diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java index 4009538b1..66693ae25 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java @@ -9,7 +9,7 @@ * * @param The exception type * @param The return type - * @see CheckedMonadicFunction + * @see CheckedFn1 */ @FunctionalInterface public interface CheckedSupplier extends Supplier { diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java index c410b6f19..aed065553 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java @@ -1,8 +1,8 @@ package com.jnape.palatable.lambda.functor; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; /** * A dually-parametric Functor that maps covariantly over both parameters. @@ -18,14 +18,14 @@ @FunctionalInterface public interface Bifunctor { - default Bifunctor biMapL(MonadicFunction fn) { + default Bifunctor biMapL(Fn1 fn) { return biMap(fn, id()); } - default Bifunctor biMapR(MonadicFunction fn) { + default Bifunctor biMapR(Fn1 fn) { return biMap(id(), fn); } - Bifunctor biMap(MonadicFunction lFn, - MonadicFunction rFn); + Bifunctor biMap(Fn1 lFn, + Fn1 rFn); } diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java index 3f7388096..6f81c7b80 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java @@ -1,6 +1,6 @@ package com.jnape.palatable.lambda.functor; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; /** * An interface for the generic covariant functorial operation map over some parameter A. @@ -12,12 +12,12 @@ * @param The type of the parameter * @see Bifunctor * @see Profunctor - * @see MonadicFunction + * @see Fn1 * @see com.jnape.palatable.lambda.adt.hlist.Tuple2 * @see com.jnape.palatable.lambda.adt.Either */ @FunctionalInterface public interface Functor { - Functor fmap(MonadicFunction fn); + Functor fmap(Fn1 fn); } diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java index cdde4a6f5..562e003b2 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java @@ -1,8 +1,8 @@ package com.jnape.palatable.lambda.functor; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; /** * A dually-parametric Functor that maps contravariantly over the first parameter and covariantly over the @@ -14,18 +14,18 @@ * @param The type of the second parameter * @see Functor * @see Bifunctor - * @see com.jnape.palatable.lambda.functions.MonadicFunction + * @see Fn1 */ @FunctionalInterface public interface Profunctor { - default Profunctor diMapL(MonadicFunction fn) { + default Profunctor diMapL(Fn1 fn) { return diMap(fn, id()); } - default Profunctor diMapR(MonadicFunction fn) { + default Profunctor diMapR(Fn1 fn) { return diMap(id(), fn); } - Profunctor diMap(MonadicFunction lFn, MonadicFunction rFn); + Profunctor diMap(Fn1 lFn, Fn1 rFn); } diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java index c3c8cd9f8..093868e5e 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/FilteringIterator.java @@ -1,16 +1,16 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import java.util.Iterator; import java.util.NoSuchElementException; public class FilteringIterator extends ImmutableIterator { - private final MonadicFunction predicate; - private final RewindableIterator rewindableIterator; + private final Fn1 predicate; + private final RewindableIterator rewindableIterator; - public FilteringIterator(MonadicFunction predicate, Iterator iterator) { + public FilteringIterator(Fn1 predicate, Iterator iterator) { this.predicate = predicate; rewindableIterator = new RewindableIterator<>(iterator); } diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java index 8a93fc2bd..f950ee386 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/MappingIterator.java @@ -1,15 +1,15 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import java.util.Iterator; public class MappingIterator extends ImmutableIterator { - private final MonadicFunction function; - private final Iterator iterator; + private final Fn1 function; + private final Iterator iterator; - public MappingIterator(MonadicFunction function, Iterator iterator) { + public MappingIterator(Fn1 function, Iterator iterator) { this.function = function; this.iterator = iterator; } diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java index 15c6bf944..02deacbf8 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIterator.java @@ -1,16 +1,16 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import java.util.Iterator; import java.util.NoSuchElementException; public class PredicatedDroppingIterator extends ImmutableIterator { - private final MonadicFunction predicate; - private final RewindableIterator rewindableIterator; - private boolean finishedDropping; + private final Fn1 predicate; + private final RewindableIterator rewindableIterator; + private boolean finishedDropping; - public PredicatedDroppingIterator(MonadicFunction predicate, Iterator asIterator) { + public PredicatedDroppingIterator(Fn1 predicate, Iterator asIterator) { this.predicate = predicate; rewindableIterator = new RewindableIterator<>(asIterator); finishedDropping = false; diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java index eb9bc32a8..3fbcd5e17 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/PredicatedTakingIterator.java @@ -1,16 +1,16 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import java.util.Iterator; import java.util.NoSuchElementException; public class PredicatedTakingIterator extends ImmutableIterator { - private final MonadicFunction predicate; - private final RewindableIterator rewindableIterator; - private boolean stillTaking; + private final Fn1 predicate; + private final RewindableIterator rewindableIterator; + private boolean stillTaking; - public PredicatedTakingIterator(MonadicFunction predicate, + public PredicatedTakingIterator(Fn1 predicate, Iterator asIterator) { this.predicate = predicate; rewindableIterator = new RewindableIterator<>(asIterator); diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java index 67529fbac..99f96cb6a 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/RewindableIterator.java @@ -8,6 +8,7 @@ public class RewindableIterator extends ImmutableIterator { private final Iterator asIterator; private final Cache cache; private boolean rewound; + public RewindableIterator(Iterator asIterator) { this.asIterator = asIterator; cache = new Cache<>(); diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java index 085ba592c..56e693629 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/ScanningIterator.java @@ -1,17 +1,17 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.DyadicFunction; +import com.jnape.palatable.lambda.functions.Fn2; import java.util.Iterator; import java.util.NoSuchElementException; public final class ScanningIterator extends ImmutableIterator { - private final DyadicFunction scanner; - private final Iterator asIterator; - private B b; + private final Fn2 scanner; + private final Iterator asIterator; + private B b; - public ScanningIterator(DyadicFunction scanner, B b, + public ScanningIterator(Fn2 scanner, B b, Iterator asIterator) { this.scanner = scanner; this.b = b; diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java index 7a5ac3585..896ca19dd 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/UnfoldingIterator.java @@ -1,16 +1,16 @@ package com.jnape.palatable.lambda.iterators; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import java.util.NoSuchElementException; import java.util.Optional; public class UnfoldingIterator extends ImmutableIterator { - private final MonadicFunction>> function; - private Optional> optionalAcc; + private final Fn1>> function; + private Optional> optionalAcc; - public UnfoldingIterator(MonadicFunction>> function, B b) { + public UnfoldingIterator(Fn1>> function, B b) { this.function = function; optionalAcc = function.apply(b); } diff --git a/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java b/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java index f8a0dc0e5..16d05c146 100644 --- a/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java +++ b/src/main/java/com/jnape/palatable/lambda/iterators/ZippingIterator.java @@ -1,15 +1,15 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.DyadicFunction; +import com.jnape.palatable.lambda.functions.Fn2; import java.util.Iterator; public class ZippingIterator extends ImmutableIterator { - private final DyadicFunction zipper; - private final Iterator asIterator; - private final Iterator bsIterator; + private final Fn2 zipper; + private final Iterator asIterator; + private final Iterator bsIterator; - public ZippingIterator(DyadicFunction zipper, Iterator asIterator, + public ZippingIterator(Fn2 zipper, Iterator asIterator, Iterator bsIterator) { this.asIterator = asIterator; this.bsIterator = bsIterator; diff --git a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java index 964e5ddfa..21cd82655 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java @@ -1,6 +1,6 @@ package com.jnape.palatable.lambda.adt; -import com.jnape.palatable.lambda.functions.DyadicFunction; +import com.jnape.palatable.lambda.functions.Fn2; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; @@ -98,8 +98,8 @@ public void mergeDuallyLiftsAndCombinesBiasingLeft() { Either left2 = left("bar"); Either right2 = right(2); - DyadicFunction concat = String::concat; - DyadicFunction add = (r1, r2) -> r1 + r2; + Fn2 concat = String::concat; + Fn2 add = (r1, r2) -> r1 + r2; assertThat(left1.merge(concat, add, left2), is(left("foobar"))); assertThat(left1.merge(concat, add, right2), is(left1)); diff --git a/src/test/java/com/jnape/palatable/lambda/functions/MonadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java similarity index 58% rename from src/test/java/com/jnape/palatable/lambda/functions/MonadicFunctionTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java index 80c87e879..06ef3d6cf 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/MonadicFunctionTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java @@ -5,20 +5,20 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.core.Is.is; -public class MonadicFunctionTest { +public class Fn1Test { @Test public void fmapComposesFunctions() { - MonadicFunction add2 = integer -> integer + 2; - MonadicFunction toString = Object::toString; + Fn1 add2 = integer -> integer + 2; + Fn1 toString = Object::toString; assertThat(add2.fmap(toString).apply(2), is(toString.apply(add2.apply(2)))); } @Test public void thenIsJustAnAliasForFmap() { - MonadicFunction add2 = integer -> integer + 2; - MonadicFunction toString = Object::toString; + Fn1 add2 = integer -> integer + 2; + Fn1 toString = Object::toString; assertThat(add2.then(toString).apply(2), is(toString.apply(add2.apply(2)))); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java similarity index 83% rename from src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java index 02a211686..12d62c4e2 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/DyadicFunctionTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java @@ -1,15 +1,15 @@ package com.jnape.palatable.lambda.functions; -import com.jnape.palatable.lambda.functions.builtin.monadic.Id; +import com.jnape.palatable.lambda.functions.builtin.fn1.Id; import org.junit.Test; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; -public class DyadicFunctionTest { +public class Fn2Test { - private static final DyadicFunction CHECK_LENGTH + private static final Fn2 CHECK_LENGTH = (string, length) -> string.length() == length; @Test @@ -37,7 +37,7 @@ public void profunctorProperties() { assertThat(CHECK_LENGTH.diMapL(Object::toString).apply(123).apply(3), is(true)); assertThat(CHECK_LENGTH.diMapR(fn -> fn.andThen(Object::toString)).apply("123").apply(3), is("true")); assertThat( - CHECK_LENGTH.>diMap( + CHECK_LENGTH.>diMap( Object::toString, fn -> fn.andThen(Object::toString) ).apply("123").apply(3), diff --git a/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn3Test.java similarity index 82% rename from src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/Fn3Test.java index eb1463188..c35532933 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/TriadicFunctionTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/Fn3Test.java @@ -6,9 +6,9 @@ import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; -public class TriadicFunctionTest { +public class Fn3Test { - private static final TriadicFunction CHECK_MULTIPLICATION = + private static final Fn3 CHECK_MULTIPLICATION = (multiplicand, multiplier, guessResult) -> multiplicand * multiplier == guessResult; @Test @@ -20,7 +20,7 @@ public void canBePartiallyApplied() { @Test public void flipsFirstAndSecondArgument() { - TriadicFunction concat3 = (a, b, c) -> a + b.toString() + c; + Fn3 concat3 = (a, b, c) -> a + b.toString() + c; assertThat(concat3.flip().apply(1, "2", "3"), is("213")); } @@ -38,7 +38,7 @@ public void functorProperties() { public void profunctorProperties() { assertThat(CHECK_MULTIPLICATION.diMapL(Integer::parseInt).apply("2").apply(3).apply(6), is(true)); assertThat(CHECK_MULTIPLICATION.diMapR(f -> f.fmap(g -> g.andThen(Object::toString))).apply(2).apply(3).apply(6), is("true")); - assertThat(CHECK_MULTIPLICATION.diMap((MonadicFunction) Integer::parseInt, + assertThat(CHECK_MULTIPLICATION.diMap((Fn1) Integer::parseInt, f -> f.fmap(g -> g.andThen(Object::toString))) .apply("2") .apply(3) diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java deleted file mode 100644 index c56e873e1..000000000 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial2Test.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import org.junit.Test; - -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Partial2.partial2; -import static org.hamcrest.core.Is.is; -import static org.junit.Assert.assertThat; - -public class Partial2Test { - - @Test - public void partiallyAppliesFunction() { - DyadicFunction subtract = (minuend, subtrahend) -> minuend - subtrahend; - - assertThat(partial2(subtract, 3).apply(2), is(1)); - } -} diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java deleted file mode 100644 index a40d53d02..000000000 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Partial3Test.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.TriadicFunction; -import org.junit.Test; - -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Partial3.partial3; -import static org.hamcrest.core.Is.is; -import static org.junit.Assert.assertThat; - -public class Partial3Test { - - @Test - public void partiallyAppliesFunction() { - TriadicFunction concat = (s1, s2, s3) -> s1 + s2 + s3; - - assertThat(partial3(concat, "foo").apply(" bar", " baz"), is("foo bar baz")); - } -} diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ConstantlyTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ConstantlyTest.java similarity index 68% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ConstantlyTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ConstantlyTest.java index 0543c48c3..1885d6902 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ConstantlyTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ConstantlyTest.java @@ -1,8 +1,8 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; import org.junit.Test; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CycleTest.java similarity index 77% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CycleTest.java index 4475989e7..f9acf8d22 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/CycleTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CycleTest.java @@ -1,4 +1,4 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; @@ -8,8 +8,8 @@ import testsupport.traits.InfiniteIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Cycle.cycle; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Cycle.cycle; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/IdTest.java similarity index 64% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/IdTest.java index 0d755a717..168a09f30 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/IdTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/IdTest.java @@ -1,8 +1,8 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; import org.junit.Test; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/RepeatTest.java similarity index 77% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/RepeatTest.java index 6e15d8634..80112707f 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/RepeatTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/RepeatTest.java @@ -1,4 +1,4 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; @@ -8,8 +8,8 @@ import testsupport.traits.InfiniteIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Repeat.repeat; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ReverseTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ReverseTest.java similarity index 91% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ReverseTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ReverseTest.java index 53d0e58f2..da6a94e45 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/monadic/ReverseTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/ReverseTest.java @@ -1,4 +1,4 @@ -package com.jnape.palatable.lambda.functions.builtin.monadic; +package com.jnape.palatable.lambda.functions.builtin.fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; @@ -11,7 +11,7 @@ import java.util.Iterator; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Reverse.reverse; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Reverse.reverse; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static org.mockito.Mockito.mock; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AllTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java similarity index 61% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AllTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java index 993e4d0a2..e95465991 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AllTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AllTest.java @@ -1,15 +1,15 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; import org.junit.runner.RunWith; import testsupport.traits.EmptyIterableSupport; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.All.all; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Repeat.repeat; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat; +import static com.jnape.palatable.lambda.functions.builtin.fn2.All.all; import static java.util.Arrays.asList; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; @@ -17,10 +17,10 @@ @RunWith(Traits.class) public class AllTest { - private static final MonadicFunction EVEN = x -> x.doubleValue() % 2 == 0; + private static final Fn1 EVEN = x -> x.doubleValue() % 2 == 0; @TestTraits({EmptyIterableSupport.class}) - public MonadicFunction, Boolean> createTestSubject() { + public Fn1, Boolean> createTestSubject() { return all(constantly(true)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AnyTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java similarity index 61% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AnyTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java index 6ace0734a..8c5485d8c 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/AnyTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/AnyTest.java @@ -1,15 +1,15 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; import org.junit.runner.RunWith; import testsupport.traits.EmptyIterableSupport; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Any.any; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Repeat.repeat; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Any.any; import static java.util.Arrays.asList; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; @@ -17,10 +17,10 @@ @RunWith(Traits.class) public class AnyTest { - public static final MonadicFunction EVEN = x -> x % 2 == 0; + public static final Fn1 EVEN = x -> x % 2 == 0; @TestTraits({EmptyIterableSupport.class}) - public MonadicFunction, Boolean> createTestSubject() { + public Fn1, Boolean> createTestSubject() { return any(constantly(true)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProductTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProductTest.java similarity index 86% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProductTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProductTest.java index d2813740e..b6b74e9e4 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/CartesianProductTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/CartesianProductTest.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -12,7 +12,7 @@ import testsupport.traits.Laziness; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.CartesianProduct.cartesianProduct; +import static com.jnape.palatable.lambda.functions.builtin.fn2.CartesianProduct.cartesianProduct; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -22,7 +22,7 @@ public class CartesianProductTest { @TestTraits({Laziness.class, ImmutableIteration.class, EmptyIterableSupport.class, FiniteIteration.class}) - public MonadicFunction, Iterable>> createTestSubject() { + public Fn1, Iterable>> createTestSubject() { return cartesianProduct(asList(1, 2, 3)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java similarity index 73% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java index 953f9d031..329fd13e2 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -10,7 +10,7 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Drop.drop; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Drop.drop; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -19,7 +19,7 @@ public class DropTest { @TestTraits({Laziness.class, ImmutableIteration.class, FiniteIteration.class, EmptyIterableSupport.class}) - public MonadicFunction, Iterable> createTestSubject() { + public Fn1, Iterable> createTestSubject() { return drop(5); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhileTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java similarity index 77% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhileTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java index a729ce240..352aa47b4 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/DropWhileTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/DropWhileTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functions.specialized.Predicate; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; @@ -11,8 +11,8 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.DropWhile.dropWhile; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn2.DropWhile.dropWhile; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.isEmpty; @@ -22,7 +22,7 @@ public class DropWhileTest { @TestTraits({Laziness.class, ImmutableIteration.class, FiniteIteration.class, EmptyIterableSupport.class}) - public MonadicFunction, Iterable> createTestSubject() { + public Fn1, Iterable> createTestSubject() { return dropWhile(constantly(true)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/FilterTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FilterTest.java similarity index 73% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/FilterTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FilterTest.java index bd534cd0c..d718c55ef 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/FilterTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FilterTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functions.specialized.Predicate; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; @@ -11,8 +11,8 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Filter.filter; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -21,7 +21,7 @@ public class FilterTest { @TestTraits({Laziness.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction createTraitsTestSubject() { + public Fn1 createTraitsTestSubject() { return filter(constantly(true)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOfTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOfTest.java similarity index 79% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOfTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOfTest.java index 1bed4b247..c341257a9 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/InGroupsOfTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/InGroupsOfTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -10,8 +10,9 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.InGroupsOf.inGroupsOf; +import static com.jnape.palatable.lambda.functions.builtin.fn2.InGroupsOf.inGroupsOf; import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -20,7 +21,7 @@ public class InGroupsOfTest { @TestTraits({Laziness.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction, Iterable>> createTestSubject() { + public Fn1, Iterable>> createTestSubject() { return inGroupsOf(2); } @@ -35,6 +36,6 @@ public void evenlyDistributesGroupedElementsOverIterable() { public void lastGroupIsUnfinishedIfIterableSizeNotEvenlyDivisibleByK() { Iterable oneThroughFive = asList(1, 2, 3, 4, 5); Iterable> groups = inGroupsOf(2, oneThroughFive); - assertThat(groups, iterates(asList(1, 2), asList(3, 4), asList(5))); + assertThat(groups, iterates(asList(1, 2), asList(3, 4), singletonList(5))); } } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/IterateTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/IterateTest.java similarity index 63% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/IterateTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/IterateTest.java index 984794010..961aa0d15 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/IterateTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/IterateTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -11,9 +11,9 @@ import java.util.ArrayList; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Iterate.iterate; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Iterate.iterate; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -21,7 +21,7 @@ public class IterateTest { @TestTraits({Laziness.class, InfiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction createTestSubject() { + public Fn1 createTestSubject() { return iterate(constantly(new ArrayList<>())); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MapTest.java similarity index 67% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MapTest.java index e6d87d765..eb4c68867 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/MapTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/MapTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -10,8 +10,8 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Map.map; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -20,13 +20,13 @@ public class MapTest { @TestTraits({Laziness.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction createTraitsTestSubject() { + public Fn1 createTraitsTestSubject() { return map(id()); } @Test public void mapsInputsIntoOutputs() { - MonadicFunction length = String::length; + Fn1 length = String::length; assertThat( map(length, asList("one", "two", "three")), iterates(3, 3, 5) diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java new file mode 100644 index 000000000..1e3a05a9a --- /dev/null +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial2Test.java @@ -0,0 +1,18 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn2; +import org.junit.Test; + +import static com.jnape.palatable.lambda.functions.builtin.fn2.Partial2.partial2; +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.assertThat; + +public class Partial2Test { + + @Test + public void partiallyAppliesFunction() { + Fn2 subtract = (minuend, subtrahend) -> minuend - subtrahend; + + assertThat(partial2(subtract, 3).apply(2), is(1)); + } +} diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java new file mode 100644 index 000000000..f939c68eb --- /dev/null +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partial3Test.java @@ -0,0 +1,18 @@ +package com.jnape.palatable.lambda.functions.builtin.fn2; + +import com.jnape.palatable.lambda.functions.Fn3; +import org.junit.Test; + +import static com.jnape.palatable.lambda.functions.builtin.fn2.Partial3.partial3; +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.assertThat; + +public class Partial3Test { + + @Test + public void partiallyAppliesFunction() { + Fn3 concat = (s1, s2, s3) -> s1 + s2 + s3; + + assertThat(partial3(concat, "foo").apply(" bar", " baz"), is("foo bar baz")); + } +} diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeftTest.java similarity index 83% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeftTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeftTest.java index 53d0bdcd5..8baf48eb8 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceLeftTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceLeftTest.java @@ -1,10 +1,10 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import org.junit.Test; import java.util.Optional; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.ReduceLeft.reduceLeft; +import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceLeft.reduceLeft; import static java.util.Arrays.asList; import static java.util.Collections.emptyList; import static org.hamcrest.core.Is.is; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRightTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRightTest.java similarity index 83% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRightTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRightTest.java index 1f2e0032f..eb4bfb8d7 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRightTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ReduceRightTest.java @@ -1,10 +1,10 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import org.junit.Test; import java.util.Optional; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.ReduceRight.reduceRight; +import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceRight.reduceRight; import static java.util.Arrays.asList; import static java.util.Collections.emptyList; import static org.hamcrest.core.Is.is; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeTest.java similarity index 76% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeTest.java index d53200943..51598a2a6 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -10,8 +10,9 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take; import static java.util.Arrays.asList; +import static java.util.Collections.emptyList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -19,7 +20,7 @@ public class TakeTest { @TestTraits({FiniteIteration.class, EmptyIterableSupport.class, ImmutableIteration.class, Laziness.class}) - public MonadicFunction, Iterable> createTestSubject() { + public Fn1, Iterable> createTestSubject() { return take(10); } @@ -37,6 +38,6 @@ public void iteratesEntireIterableIfLessElementsThanLimit() { @Test public void takesNothingFromEmptyIterable() { - assertThat(take(1, asList()), iterates()); + assertThat(take(1, emptyList()), iterates()); } } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhileTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhileTest.java similarity index 79% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhileTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhileTest.java index ed75773c0..871bd3a6e 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/TakeWhileTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/TakeWhileTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functions.specialized.Predicate; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; @@ -11,8 +11,8 @@ import testsupport.traits.ImmutableIteration; import testsupport.traits.Laziness; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.TakeWhile.takeWhile; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly; +import static com.jnape.palatable.lambda.functions.builtin.fn2.TakeWhile.takeWhile; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.isEmpty; @@ -22,7 +22,7 @@ public class TakeWhileTest { @TestTraits({FiniteIteration.class, EmptyIterableSupport.class, ImmutableIteration.class, Laziness.class}) - public MonadicFunction, Iterable> createTestObject() { + public Fn1, Iterable> createTestObject() { return takeWhile(constantly(true)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2Test.java similarity index 68% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2Test.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2Test.java index b909c6feb..6eff737aa 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/Tupler2Test.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/Tupler2Test.java @@ -1,9 +1,9 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import org.junit.Test; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Tupler2.tupler; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Tupler2.tupler; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/UnfoldrTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/UnfoldrTest.java similarity index 70% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/UnfoldrTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/UnfoldrTest.java index 9d53ee2f9..ed23697fa 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/UnfoldrTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/UnfoldrTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -12,8 +12,8 @@ import java.util.Optional; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Take.take; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Unfoldr.unfoldr; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Unfoldr.unfoldr; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -21,7 +21,7 @@ public class UnfoldrTest { @TestTraits({Laziness.class, InfiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction createTestSubject() { + public Fn1 createTestSubject() { return unfoldr(x -> Optional.of(tuple(x, x))); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ZipTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ZipTest.java similarity index 78% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ZipTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ZipTest.java index 14efd3d28..69f1545d7 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ZipTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ZipTest.java @@ -1,7 +1,7 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; +package com.jnape.palatable.lambda.functions.builtin.fn2; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -13,7 +13,7 @@ import java.util.Arrays; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Zip.zip; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Zip.zip; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -22,7 +22,7 @@ public class ZipTest { @TestTraits({Laziness.class, FiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction, Iterable>> createTestSubject() { + public Fn1, Iterable>> createTestSubject() { return zip(Arrays.asList(1, 2, 3)); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeftTest.java similarity index 64% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeftTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeftTest.java index 6f0e4757f..1e6da60ab 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldLeftTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldLeftTest.java @@ -1,14 +1,15 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; +package com.jnape.palatable.lambda.functions.builtin.fn3; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; import org.junit.runner.RunWith; import testsupport.traits.EmptyIterableSupport; -import static com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft.foldLeft; +import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldLeft.foldLeft; import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; import static testsupport.functions.ExplainFold.explainFold; @@ -17,8 +18,8 @@ public class FoldLeftTest { @TestTraits({EmptyIterableSupport.class}) - public MonadicFunction, Iterable> createTestSubject() { - return foldLeft((objects, o) -> objects, asList(new Object())); + public Fn1, Iterable> createTestSubject() { + return foldLeft((objects, o) -> objects, singletonList(new Object())); } @Test diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRightTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRightTest.java similarity index 64% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRightTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRightTest.java index 9068f223b..b40915da7 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/FoldRightTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/FoldRightTest.java @@ -1,14 +1,15 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; +package com.jnape.palatable.lambda.functions.builtin.fn3; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; import org.junit.runner.RunWith; import testsupport.traits.EmptyIterableSupport; -import static com.jnape.palatable.lambda.functions.builtin.triadic.FoldRight.foldRight; +import static com.jnape.palatable.lambda.functions.builtin.fn3.FoldRight.foldRight; import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; import static testsupport.functions.ExplainFold.explainFold; @@ -17,8 +18,8 @@ public class FoldRightTest { @TestTraits({EmptyIterableSupport.class}) - public MonadicFunction, Iterable> createTestSubject() { - return foldRight((o, objects) -> objects, asList(new Object())); + public Fn1, Iterable> createTestSubject() { + return foldRight((o, objects) -> objects, singletonList(new Object())); } @Test diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeftTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeftTest.java similarity index 79% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeftTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeftTest.java index 621f94fc4..e031e22a2 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ScanLeftTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ScanLeftTest.java @@ -1,6 +1,6 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; +package com.jnape.palatable.lambda.functions.builtin.fn3; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -11,7 +11,7 @@ import java.util.Collections; -import static com.jnape.palatable.lambda.functions.builtin.triadic.ScanLeft.scanLeft; +import static com.jnape.palatable.lambda.functions.builtin.fn3.ScanLeft.scanLeft; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -20,7 +20,7 @@ public class ScanLeftTest { @TestTraits({EmptyIterableSupport.class, FiniteIteration.class, Laziness.class}) - public MonadicFunction, Iterable> createTestSubject() { + public Fn1, Iterable> createTestSubject() { return scanLeft((x, y) -> x, new Object()); } diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWithTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java similarity index 74% rename from src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWithTest.java rename to src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java index 604a0ff15..0fcc085ad 100644 --- a/src/test/java/com/jnape/palatable/lambda/functions/builtin/triadic/ZipWithTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn3/ZipWithTest.java @@ -1,8 +1,8 @@ -package com.jnape.palatable.lambda.functions.builtin.triadic; +package com.jnape.palatable.lambda.functions.builtin.fn3; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; +import com.jnape.palatable.lambda.functions.Fn2; import com.jnape.palatable.traitor.annotations.TestTraits; import com.jnape.palatable.traitor.runners.Traits; import org.junit.Test; @@ -12,8 +12,8 @@ import testsupport.traits.Laziness; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; -import static com.jnape.palatable.lambda.functions.builtin.dyadic.Zip.zip; -import static com.jnape.palatable.lambda.functions.builtin.triadic.ZipWith.zipWith; +import static com.jnape.palatable.lambda.functions.builtin.fn2.Zip.zip; +import static com.jnape.palatable.lambda.functions.builtin.fn3.ZipWith.zipWith; import static java.util.Arrays.asList; import static org.junit.Assert.assertThat; import static testsupport.matchers.IterableMatcher.iterates; @@ -22,7 +22,7 @@ public class ZipWithTest { @TestTraits({Laziness.class, FiniteIteration.class, ImmutableIteration.class}) - public MonadicFunction, Iterable> createTestSubject() { + public Fn1, Iterable> createTestSubject() { return zipWith((o, o2) -> new Object(), asList(1, 2, 3)); } @@ -31,7 +31,7 @@ public void zipsTwoIterablesTogetherWithFunction() { Iterable oneThroughFive = asList(1, 2, 3, 4, 5); Iterable sixThroughTen = asList(6, 7, 8, 9, 10); - DyadicFunction add = (a, b) -> a + b; + Fn2 add = (a, b) -> a + b; Iterable sums = ZipWith.zipWith(add, oneThroughFive, sixThroughTen); assertThat(sums, iterates(7, 9, 11, 13, 15)); diff --git a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java index d8433c53a..6d78c167d 100644 --- a/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functor/BifunctorTest.java @@ -1,12 +1,12 @@ package com.jnape.palatable.lambda.functor; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import org.junit.Test; import testsupport.applicatives.InvocationRecordingBifunctor; import java.util.concurrent.atomic.AtomicReference; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; @@ -14,7 +14,7 @@ public class BifunctorTest { @Test public void biMapLUsesIdentityForRightBiMapFunction() { - AtomicReference rightInvocation = new AtomicReference<>(); + AtomicReference rightInvocation = new AtomicReference<>(); Bifunctor bifunctor = new InvocationRecordingBifunctor<>(new AtomicReference<>(), rightInvocation); bifunctor.biMapL(String::toUpperCase); assertThat(rightInvocation.get(), is(id())); @@ -22,7 +22,7 @@ public void biMapLUsesIdentityForRightBiMapFunction() { @Test public void biMapRUsesIdentityForLeftBiMapFunction() { - AtomicReference leftInvocation = new AtomicReference<>(); + AtomicReference leftInvocation = new AtomicReference<>(); Bifunctor bifunctor = new InvocationRecordingBifunctor<>(leftInvocation, new AtomicReference<>()); bifunctor.biMapR(String::valueOf); assertThat(leftInvocation.get(), is(id())); diff --git a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java index 9c0252620..63011de85 100644 --- a/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/functor/ProfunctorTest.java @@ -1,12 +1,12 @@ package com.jnape.palatable.lambda.functor; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import org.junit.Test; import testsupport.applicatives.InvocationRecordingProfunctor; import java.util.concurrent.atomic.AtomicReference; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Id.id; +import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; @@ -14,7 +14,7 @@ public class ProfunctorTest { @Test public void diMapLUsesIdentityForRightDiMapFunction() { - AtomicReference rightInvocation = new AtomicReference<>(); + AtomicReference rightInvocation = new AtomicReference<>(); Profunctor profunctor = new InvocationRecordingProfunctor<>(new AtomicReference<>(), rightInvocation); profunctor.diMapL(Object::toString); assertThat(rightInvocation.get(), is(id())); @@ -22,7 +22,7 @@ public void diMapLUsesIdentityForRightDiMapFunction() { @Test public void diMapRUsesIdentityForLeftDiMapFunction() { - AtomicReference leftInvocation = new AtomicReference<>(); + AtomicReference leftInvocation = new AtomicReference<>(); Profunctor profunctor = new InvocationRecordingProfunctor<>(leftInvocation, new AtomicReference<>()); profunctor.diMapR(String::valueOf); assertThat(leftInvocation.get(), is(id())); diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java index 314f478d1..da1469db9 100644 --- a/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/iterators/MappingIteratorTest.java @@ -1,6 +1,6 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import org.junit.Test; import java.util.List; @@ -13,7 +13,7 @@ public class MappingIteratorTest { @Test public void nextProducesMappedResult() { - MonadicFunction stringToLength = String::length; + Fn1 stringToLength = String::length; List words = asList("foo", "bar"); MappingIterator mappingIterator = new MappingIterator<>(stringToLength, words.iterator()); diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java index c5a2c9875..b597da2a0 100644 --- a/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/iterators/PredicatedDroppingIteratorTest.java @@ -1,6 +1,6 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -17,7 +17,7 @@ @RunWith(MockitoJUnitRunner.class) public class PredicatedDroppingIteratorTest { - private static final MonadicFunction EVEN = x -> x % 2 == 0; + private static final Fn1 EVEN = x -> x % 2 == 0; @Mock private Iterator iterator; diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java index ed93c0042..b082925ab 100644 --- a/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/iterators/ScanningIteratorTest.java @@ -1,5 +1,6 @@ package com.jnape.palatable.lambda.iterators; +import com.jnape.palatable.lambda.functions.Fn2; import org.junit.Test; import java.util.NoSuchElementException; @@ -11,7 +12,7 @@ public class ScanningIteratorTest { - public static final com.jnape.palatable.lambda.functions.DyadicFunction ADD = (x, y) -> x + y; + public static final Fn2 ADD = (x, y) -> x + y; @Test public void hasNextAtLeastForB() { diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java index 85574e661..1aadfde06 100644 --- a/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/iterators/UnfoldingIteratorTest.java @@ -1,7 +1,7 @@ package com.jnape.palatable.lambda.iterators; import com.jnape.palatable.lambda.adt.hlist.Tuple2; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import org.junit.Test; import java.util.Optional; @@ -12,7 +12,7 @@ public class UnfoldingIteratorTest { - private static final MonadicFunction>> STRINGIFY = x -> Optional.of(tuple(x.toString(), x + 1)); + private static final Fn1>> STRINGIFY = x -> Optional.of(tuple(x.toString(), x + 1)); @Test public void hasNextIfFunctionProducesPresentValue() { diff --git a/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java b/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java index acceae48f..e80c53acd 100644 --- a/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java +++ b/src/test/java/com/jnape/palatable/lambda/iterators/ZippingIteratorTest.java @@ -1,6 +1,6 @@ package com.jnape.palatable.lambda.iterators; -import com.jnape.palatable.lambda.functions.DyadicFunction; +import com.jnape.palatable.lambda.functions.Fn2; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -17,9 +17,9 @@ @RunWith(MockitoJUnitRunner.class) public class ZippingIteratorTest { - @Mock private DyadicFunction zipper; - @Mock private Iterator as; - @Mock private Iterator bs; + @Mock private Fn2 zipper; + @Mock private Iterator as; + @Mock private Iterator bs; private ZippingIterator zippingIterator; diff --git a/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java b/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java index 191df47c6..51b2fa24c 100644 --- a/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java +++ b/src/test/java/testsupport/applicatives/InvocationRecordingBifunctor.java @@ -1,24 +1,24 @@ package testsupport.applicatives; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Bifunctor; import java.util.concurrent.atomic.AtomicReference; public final class InvocationRecordingBifunctor implements Bifunctor { - private final AtomicReference leftFn; - private final AtomicReference rightFn; + private final AtomicReference leftFn; + private final AtomicReference rightFn; - public InvocationRecordingBifunctor(AtomicReference leftFn, - AtomicReference rightFn) { + public InvocationRecordingBifunctor(AtomicReference leftFn, + AtomicReference rightFn) { this.leftFn = leftFn; this.rightFn = rightFn; } @Override @SuppressWarnings("unchecked") - public Bifunctor biMap(MonadicFunction lFn, - MonadicFunction rFn) { + public Bifunctor biMap(Fn1 lFn, + Fn1 rFn) { leftFn.set(lFn); rightFn.set(rFn); return (Bifunctor) this; diff --git a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java index 8904c2afc..a5de7891b 100644 --- a/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java +++ b/src/test/java/testsupport/applicatives/InvocationRecordingProfunctor.java @@ -1,23 +1,23 @@ package testsupport.applicatives; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Profunctor; import java.util.concurrent.atomic.AtomicReference; public final class InvocationRecordingProfunctor implements Profunctor { - private final AtomicReference leftFn; - private final AtomicReference rightFn; + private final AtomicReference leftFn; + private final AtomicReference rightFn; - public InvocationRecordingProfunctor(AtomicReference leftFn, - AtomicReference rightFn) { + public InvocationRecordingProfunctor(AtomicReference leftFn, + AtomicReference rightFn) { this.leftFn = leftFn; this.rightFn = rightFn; } @Override @SuppressWarnings("unchecked") - public Profunctor diMap(MonadicFunction lFn, MonadicFunction rFn) { + public Profunctor diMap(Fn1 lFn, Fn1 rFn) { leftFn.set(lFn); rightFn.set(rFn); return (Profunctor) this; diff --git a/src/test/java/testsupport/functions/ExplainFold.java b/src/test/java/testsupport/functions/ExplainFold.java index 9466e6339..d59a2378b 100644 --- a/src/test/java/testsupport/functions/ExplainFold.java +++ b/src/test/java/testsupport/functions/ExplainFold.java @@ -1,12 +1,12 @@ package testsupport.functions; -import com.jnape.palatable.lambda.functions.DyadicFunction; +import com.jnape.palatable.lambda.functions.Fn2; import static java.lang.String.format; public class ExplainFold { - public static DyadicFunction explainFold() { + public static Fn2 explainFold() { return (acc, x) -> format("(%s + %s)", acc, x); } } diff --git a/src/test/java/testsupport/traits/EmptyIterableSupport.java b/src/test/java/testsupport/traits/EmptyIterableSupport.java index bd361de21..a0d2d029a 100644 --- a/src/test/java/testsupport/traits/EmptyIterableSupport.java +++ b/src/test/java/testsupport/traits/EmptyIterableSupport.java @@ -1,14 +1,14 @@ package testsupport.traits; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.traits.Trait; import java.util.ArrayList; -public class EmptyIterableSupport implements Trait> { +public class EmptyIterableSupport implements Trait> { @Override - public void test(MonadicFunction testSubject) { + public void test(Fn1 testSubject) { try { testSubject.apply(new ArrayList()); } catch (Exception e) { diff --git a/src/test/java/testsupport/traits/FiniteIteration.java b/src/test/java/testsupport/traits/FiniteIteration.java index 5dc53be05..882632f17 100644 --- a/src/test/java/testsupport/traits/FiniteIteration.java +++ b/src/test/java/testsupport/traits/FiniteIteration.java @@ -1,6 +1,6 @@ package testsupport.traits; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.traits.Trait; import static java.util.Arrays.asList; @@ -8,10 +8,10 @@ import static org.hamcrest.core.Is.is; import static testsupport.matchers.FiniteIterableMatcher.finitelyIterable; -public class FiniteIteration implements Trait> { +public class FiniteIteration implements Trait> { @Override - public void test(MonadicFunction testSubject) { + public void test(Fn1 testSubject) { Iterable result = testSubject.apply(asList(1, 2, 3)); assertThat(result, is(finitelyIterable())); } diff --git a/src/test/java/testsupport/traits/ImmutableIteration.java b/src/test/java/testsupport/traits/ImmutableIteration.java index 2efd1dc2d..ce6e7db55 100644 --- a/src/test/java/testsupport/traits/ImmutableIteration.java +++ b/src/test/java/testsupport/traits/ImmutableIteration.java @@ -1,16 +1,16 @@ package testsupport.traits; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.traits.Trait; import java.util.ArrayList; import static org.junit.Assert.fail; -public class ImmutableIteration implements Trait> { +public class ImmutableIteration implements Trait> { @Override - public void test(MonadicFunction testSubject) { + public void test(Fn1 testSubject) { Iterable result = testSubject.apply(new ArrayList()); try { result.iterator().remove(); diff --git a/src/test/java/testsupport/traits/InfiniteIteration.java b/src/test/java/testsupport/traits/InfiniteIteration.java index 785bd96aa..12072fe78 100644 --- a/src/test/java/testsupport/traits/InfiniteIteration.java +++ b/src/test/java/testsupport/traits/InfiniteIteration.java @@ -1,6 +1,6 @@ package testsupport.traits; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.traits.Trait; import static java.util.Arrays.asList; @@ -9,10 +9,10 @@ import static org.hamcrest.core.Is.is; import static testsupport.matchers.FiniteIterableMatcher.finitelyIterable; -public class InfiniteIteration implements Trait> { +public class InfiniteIteration implements Trait> { @Override - public void test(MonadicFunction testSubject) { + public void test(Fn1 testSubject) { Iterable result = testSubject.apply(asList(1, 2, 3)); assertThat(result, is(not(finitelyIterable()))); } diff --git a/src/test/java/testsupport/traits/Laziness.java b/src/test/java/testsupport/traits/Laziness.java index 3aa3ca24e..216201df7 100644 --- a/src/test/java/testsupport/traits/Laziness.java +++ b/src/test/java/testsupport/traits/Laziness.java @@ -1,16 +1,16 @@ package testsupport.traits; -import com.jnape.palatable.lambda.functions.MonadicFunction; +import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.traitor.traits.Trait; import static org.junit.Assert.assertThat; import static testsupport.Mocking.mockIterable; import static testsupport.matchers.ZeroInvocationsMatcher.wasNeverInteractedWith; -public class Laziness implements Trait> { +public class Laziness implements Trait> { @Override - public void test(MonadicFunction testSubject) { + public void test(Fn1 testSubject) { Iterable iterable = mockIterable(); testSubject.apply(iterable); From 87ed77123b56ac4da8e45ae173aa916646c5b19d Mon Sep 17 00:00:00 2001 From: jnape Date: Sun, 10 Jul 2016 00:34:43 -0500 Subject: [PATCH 09/11] Renaming Singleton to SingletonHList --- .../jnape/palatable/lambda/adt/hlist/HList.java | 12 ++++++------ .../hlist/{Singleton.java => SingletonHList.java} | 8 ++++---- .../jnape/palatable/lambda/adt/hlist/Tuple2.java | 8 ++++---- .../jnape/palatable/lambda/adt/hlist/Tuple3.java | 2 +- .../jnape/palatable/lambda/adt/hlist/Tuple4.java | 2 +- .../jnape/palatable/lambda/adt/hlist/Tuple5.java | 2 +- .../palatable/lambda/adt/hlist/HListTest.java | 4 ++-- ...{SingletonTest.java => SingletonHListTest.java} | 14 +++++++------- .../palatable/lambda/adt/hlist/Tuple2Test.java | 8 ++++---- .../palatable/lambda/adt/hlist/Tuple3Test.java | 8 ++++---- .../palatable/lambda/adt/hlist/Tuple4Test.java | 8 ++++---- .../palatable/lambda/adt/hlist/Tuple5Test.java | 8 ++++---- 12 files changed, 42 insertions(+), 42 deletions(-) rename src/main/java/com/jnape/palatable/lambda/adt/hlist/{Singleton.java => SingletonHList.java} (68%) rename src/test/java/com/jnape/palatable/lambda/adt/hlist/{SingletonTest.java => SingletonHListTest.java} (50%) diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java index feee8be92..995e1b4f2 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java @@ -8,7 +8,7 @@ * * @param The head element type * @param The encoded recursive tail HList type - * @see Singleton + * @see SingletonHList * @see Tuple2 * @see Tuple3 * @see Tuple4 @@ -29,12 +29,12 @@ public static HNil nil() { return new HCons<>(head, tail); } - public static Singleton singleton(Head head) { - return new Singleton<>(head); + public static SingletonHList singletonHList(Head head) { + return new SingletonHList<>(head); } public static <_1, _2> Tuple2<_1, _2> tuple(_1 _1, _2 _2) { - return singleton(_2).cons(_1); + return singletonHList(_2).cons(_1); } public static <_1, _2, _3> Tuple3<_1, _2, _3> tuple(_1 _1, _2 _2, _3 _3) { @@ -100,8 +100,8 @@ public static final class HNil extends HList { private static final HNil INSTANCE = new HNil(); @Override - public Singleton cons(Head head) { - return new Singleton<>(head); + public SingletonHList cons(Head head) { + return new SingletonHList<>(head); } @Override diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java similarity index 68% rename from src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java rename to src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java index cfa575ea6..cacfbecb5 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Singleton.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java @@ -15,9 +15,9 @@ * @see Tuple4 * @see Tuple5 */ -public final class Singleton<_1> extends HCons<_1, HNil> implements Functor<_1> { +public final class SingletonHList<_1> extends HCons<_1, HNil> implements Functor<_1> { - Singleton(_1 _1) { + SingletonHList(_1 _1) { super(_1, nil()); } @@ -27,7 +27,7 @@ public <_0> Tuple2<_0, _1> cons(_0 _0) { } @Override - public <_1Prime> Singleton<_1Prime> fmap(Fn1 fn) { - return new Singleton<>(fn.apply(head())); + public <_1Prime> SingletonHList<_1Prime> fmap(Fn1 fn) { + return new SingletonHList<>(fn.apply(head())); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java index f57541d0b..e44df2135 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java @@ -13,14 +13,14 @@ * @param <_1> The first slot element type * @param <_2> The second slot element type * @see HList - * @see Singleton + * @see SingletonHList * @see Tuple3 * @see Tuple4 * @see Tuple5 */ -public final class Tuple2<_1, _2> extends HCons<_1, Singleton<_2>> implements Map.Entry<_1, _2>, Functor<_2>, Bifunctor<_1, _2> { +public final class Tuple2<_1, _2> extends HCons<_1, SingletonHList<_2>> implements Map.Entry<_1, _2>, Functor<_2>, Bifunctor<_1, _2> { - Tuple2(_1 _1, Singleton<_2> tail) { + Tuple2(_1 _1, SingletonHList<_2> tail) { super(_1, tail); } @@ -76,6 +76,6 @@ public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(Fn1 Tuple2 fromEntry(Map.Entry entry) { - return new Tuple2<>(entry.getKey(), singleton(entry.getValue())); + return new Tuple2<>(entry.getKey(), singletonHList(entry.getValue())); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java index 449013243..2c9d8c848 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java @@ -12,7 +12,7 @@ * @param <_2> The second slot element type * @param <_3> The third slot element type * @see HList - * @see Singleton + * @see SingletonHList * @see Tuple2 * @see Tuple4 * @see Tuple5 diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java index 04416e534..208cdc553 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java @@ -13,7 +13,7 @@ * @param <_3> The third slot element type * @param <_4> The fourth slot element type * @see HList - * @see Singleton + * @see SingletonHList * @see Tuple2 * @see Tuple3 * @see Tuple5 diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java index 1bc4bfa5c..4da6f6a84 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java @@ -14,7 +14,7 @@ * @param <_4> The fourth slot element type * @param <_5> The fifth slot element type * @see HList - * @see Singleton + * @see SingletonHList * @see Tuple2 * @see Tuple3 * @see Tuple4 diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java index 425fb9a02..6be65b6dc 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/HListTest.java @@ -4,7 +4,7 @@ import static com.jnape.palatable.lambda.adt.hlist.HList.cons; import static com.jnape.palatable.lambda.adt.hlist.HList.nil; -import static com.jnape.palatable.lambda.adt.hlist.HList.singleton; +import static com.jnape.palatable.lambda.adt.hlist.HList.singletonHList; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -29,7 +29,7 @@ public void tail() { @Test public void convenienceStaticFactoryMethods() { assertEquals(nil().cons(1), cons(1, nil())); - assertEquals(nil().cons(1), singleton(1)); + assertEquals(nil().cons(1), singletonHList(1)); assertEquals(nil().cons('2').cons(1), tuple(1, '2')); assertEquals(nil().cons("3").cons('2').cons(1), tuple(1, '2', "3")); assertEquals(nil().cons(4.0).cons("3").cons('2').cons(1), tuple(1, '2', "3", 4.0)); diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonHListTest.java similarity index 50% rename from src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonTest.java rename to src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonHListTest.java index 3b062d372..18bc68a05 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonTest.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/SingletonHListTest.java @@ -6,32 +6,32 @@ import static com.jnape.palatable.lambda.adt.hlist.HList.nil; import static org.junit.Assert.assertEquals; -public class SingletonTest { +public class SingletonHListTest { - private Singleton singleton; + private SingletonHList singletonHList; @Before public void setUp() { - singleton = new Singleton<>(1); + singletonHList = new SingletonHList<>(1); } @Test public void head() { - assertEquals((Integer) 1, singleton.head()); + assertEquals((Integer) 1, singletonHList.head()); } @Test public void tail() { - assertEquals(nil(), singleton.tail()); + assertEquals(nil(), singletonHList.tail()); } @Test public void cons() { - assertEquals(new Tuple2<>("0", singleton), singleton.cons("0")); + assertEquals(new Tuple2<>("0", singletonHList), singletonHList.cons("0")); } @Test public void functorProperties() { - assertEquals(new Singleton<>("1"), singleton.fmap(Object::toString)); + assertEquals(new SingletonHList<>("1"), singletonHList.fmap(Object::toString)); } } \ No newline at end of file diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java index d74518bba..7326e08bd 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java @@ -15,7 +15,7 @@ public class Tuple2Test { @Before public void setUp() throws Exception { - tuple2 = new Tuple2<>(1, new Singleton<>(2)); + tuple2 = new Tuple2<>(1, new SingletonHList<>(2)); } @Test @@ -25,7 +25,7 @@ public void head() { @Test public void tail() { - assertEquals(new Singleton<>(2), tuple2.tail()); + assertEquals(new SingletonHList<>(2), tuple2.tail()); } @Test @@ -41,12 +41,12 @@ public void accessors() { @Test public void functorProperties() { - assertEquals(new Tuple2<>(1, new Singleton<>("2")), tuple2.fmap(Object::toString)); + assertEquals(new Tuple2<>(1, new SingletonHList<>("2")), tuple2.fmap(Object::toString)); } @Test public void bifunctorProperties() { - assertEquals(new Tuple2<>("1", new Singleton<>("2")), tuple2.biMap(Object::toString, Object::toString)); + assertEquals(new Tuple2<>("1", new SingletonHList<>("2")), tuple2.biMap(Object::toString, Object::toString)); } @Test diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java index 9aa335811..8f05eae76 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java @@ -11,7 +11,7 @@ public class Tuple3Test { @Before public void setUp() { - tuple3 = new Tuple3<>(1, new Tuple2<>("2", new Singleton<>('3'))); + tuple3 = new Tuple3<>(1, new Tuple2<>("2", new SingletonHList<>('3'))); } @Test @@ -21,7 +21,7 @@ public void head() { @Test public void tail() { - assertEquals(new Tuple2<>("2", new Singleton<>('3')), tuple3.tail()); + assertEquals(new Tuple2<>("2", new SingletonHList<>('3')), tuple3.tail()); } @Test @@ -38,11 +38,11 @@ public void accessors() { @Test public void functorProperties() { - assertEquals(new Tuple3<>(1, new Tuple2<>("2", new Singleton<>("3"))), tuple3.fmap(Object::toString)); + assertEquals(new Tuple3<>(1, new Tuple2<>("2", new SingletonHList<>("3"))), tuple3.fmap(Object::toString)); } @Test public void bifunctorProperties() { - assertEquals(new Tuple3<>(1, new Tuple2<>(2, new Singleton<>("3"))), tuple3.biMap(Integer::parseInt, Object::toString)); + assertEquals(new Tuple3<>(1, new Tuple2<>(2, new SingletonHList<>("3"))), tuple3.biMap(Integer::parseInt, Object::toString)); } } diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java index 1213ec5a5..c31e7915d 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java @@ -11,7 +11,7 @@ public class Tuple4Test { @Before public void setUp() { - tuple4 = new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new Singleton<>(false)))); + tuple4 = new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(false)))); } @Test @@ -21,7 +21,7 @@ public void head() { @Test public void tail() { - assertEquals(new Tuple3<>("2", new Tuple2<>('3', new Singleton<>(false))), tuple4.tail()); + assertEquals(new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(false))), tuple4.tail()); } @Test @@ -39,12 +39,12 @@ public void accessors() { @Test public void functorProperties() { - assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new Singleton<>(true)))), tuple4.fmap(x -> !x)); + assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(true)))), tuple4.fmap(x -> !x)); } @Test public void bifunctorProperties() { - assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>("3", new Singleton<>(true)))), + assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>("3", new SingletonHList<>(true)))), tuple4.biMap(Object::toString, x -> !x)); } } \ No newline at end of file diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java index 2745f3c47..cb6b43771 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java @@ -12,7 +12,7 @@ public class Tuple5Test { @Before public void setUp() { - tuple5 = new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new Singleton<>(5L))))); + tuple5 = new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>(5L))))); } @Test @@ -22,7 +22,7 @@ public void head() { @Test public void tail() { - assertEquals(new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new Singleton<>(5L)))), tuple5.tail()); + assertEquals(new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>(5L)))), tuple5.tail()); } @Test @@ -41,13 +41,13 @@ public void accessors() { @Test public void functorProperties() { - assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new Singleton<>("5"))))), + assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>("5"))))), tuple5.fmap(Object::toString)); } @Test public void bifunctorProperties() { - assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(true, new Singleton<>("5"))))), + assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(true, new SingletonHList<>("5"))))), tuple5.biMap(x -> !x, Object::toString)); } } \ No newline at end of file From 0db0e071c8814c7dbef952b34edece130a75d211 Mon Sep 17 00:00:00 2001 From: jnape Date: Mon, 25 Jul 2016 00:34:24 -0500 Subject: [PATCH 10/11] HList subtype specializations 2-element and up (Tuple2 - Tuple5) now support constant time element lookup using custom accessors. Adding copious amounts of missing JavaDoc --- .../jnape/palatable/lambda/adt/Either.java | 157 ++++++++++++++++-- .../palatable/lambda/adt/hlist/HList.java | 97 ++++++++++- .../lambda/adt/hlist/SingletonHList.java | 6 +- .../palatable/lambda/adt/hlist/Tuple2.java | 31 +++- .../palatable/lambda/adt/hlist/Tuple3.java | 32 +++- .../palatable/lambda/adt/hlist/Tuple4.java | 41 ++++- .../palatable/lambda/adt/hlist/Tuple5.java | 59 +++++-- .../jnape/palatable/lambda/adt/hmap/HMap.java | 88 +++++++++- .../lambda/adt/hmap/TypeSafeKey.java | 6 + .../jnape/palatable/lambda/functions/Fn1.java | 77 ++++++++- .../jnape/palatable/lambda/functions/Fn2.java | 27 ++- .../jnape/palatable/lambda/functions/Fn3.java | 34 +++- .../functions/specialized/Predicate.java | 48 ++++++ .../specialized/checked/CheckedFn1.java | 7 + .../specialized/checked/CheckedSupplier.java | 6 + .../palatable/lambda/functor/Bifunctor.java | 34 +++- .../palatable/lambda/functor/Functor.java | 8 + .../palatable/lambda/functor/Profunctor.java | 37 ++++- .../lambda/adt/hlist/Tuple2Test.java | 16 ++ .../lambda/adt/hlist/Tuple3Test.java | 18 ++ .../lambda/adt/hlist/Tuple4Test.java | 20 +++ .../lambda/adt/hlist/Tuple5Test.java | 22 +++ 22 files changed, 805 insertions(+), 66 deletions(-) diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java index e6481194b..371e5d355 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/Either.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/Either.java @@ -26,39 +26,110 @@ public abstract class Either implements Functor, Bifunctor { private Either() { } + /** + * Return the value wrapped by this Either if it's a right value; otherwise, return defaultValue. + * + * @param defaultValue the value to return if this is a left + * @return the value wrapped by this Either if right; otherwise, defaultValue + */ public final R or(R defaultValue) { return recover(l -> defaultValue); } + /** + * "Recover" from a left value by applying a recoveryFn to the wrapped value and returning it in the case of a left + * value; otherwise, return the wrapped right value. + * + * @param recoveryFn a function from L to R + * @return either the wrapped value (if right) or the result of the left value applied to recoveryFn + */ public final R recover(Fn1 recoveryFn) { return match(recoveryFn, id()); } + /** + * Inverse of recover. If this is a right value, apply the wrapped value to forfeitFn and return it; otherwise, + * return the wrapped left value; + * + * @param forfeitFn a function from R to L + * @return either the wrapped value (if left) or the result of the right value applied to forfeitFn + */ public final L forfeit(Fn1 forfeitFn) { return match(id(), forfeitFn); } - public final R orThrow( - Fn1 throwableFn) throws E { + /** + * Return the wrapped value if this is a right; otherwise, map the wrapped left value to an E and throw + * it. + * + * @param throwableFn a function from L to E + * @param the left parameter type (the throwable exception type) + * @return the wrapped value if this is a right + * @throws E the result of applying the wrapped left value to throwableFn, if this is a left + */ + public final R orThrow(Fn1 throwableFn) throws E { return match(l -> { throw throwableFn.apply(l); }, id()); } - public final Either filter(Fn1 pred, - Supplier leftSupplier) { + /** + * If this is a right value, apply pred to it. If the result is true, return the same value; otherwise, return the + * result of leftSupplier wrapped as a left value. + *

+ * If this is a left value, return it. + * + * @param pred the predicate to apply to a right value + * @param leftSupplier the supplier of a left value if pred fails + * @return this if a left value or a right value that pred matches; otherwise, the result of leftSupplier wrapped in + * a left + */ + public final Either filter(Fn1 pred, Supplier leftSupplier) { return flatMap(r -> pred.apply(r) ? right(r) : left(leftSupplier.get())); } + /** + * If a right value, unwrap it and apply it to rightFn, returning the resulting + * Either<L ,R>. Otherwise, return the left value. + *

+ * Note that because this monadic form of flatMap only supports mapping over a theoretical right value, + * the resulting Either must be invariant on the same left value to flatten properly. + * + * @param rightFn the function to apply to a right value + * @param the new right parameter type + * @return the Either resulting from applying rightFn to this right value, or this left value if left + */ public final Either flatMap(Fn1> rightFn) { return flatMap(Either::left, rightFn); } + /** + * If a right value, apply rightFn to the unwrapped right value and return the resulting + * Either; otherwise, apply the unwrapped left value to leftFn and return the resulting + * Either. + * + * @param leftFn the function to apply if a left value + * @param rightFn the function to apply if a right value + * @param the new left parameter type + * @param the new right parameter type + * @return the result of either rightFn or leftFn, depending on whether this is a right or a left + */ public final Either flatMap(Fn1> leftFn, Fn1> rightFn) { return match(leftFn, rightFn); } + /** + * Given two binary operators over L and R, merge two Either<L, R>s into a single + * Either<L, R>. Note that merge biases towards left values; that is, if any left + * value exists, the result will be a left value, such that only unanimous right values result in an ultimate right + * value. + * + * @param leftFn the binary operator for L + * @param rightFn the binary operator for R + * @param other the other Either + * @return the merged Either + */ public final Either merge(Fn2 leftFn, Fn2 rightFn, Either other) { @@ -67,11 +138,24 @@ public final Either merge(Fn2 leftFn, r1 -> other.match(Either::left, r2 -> right(rightFn.apply(r1, r2)))); } + /** + * Perform side-effects against a wrapped right value, returning back the Either unaltered. + * + * @param rightConsumer the effecting consumer + * @return the Either, unaltered + */ public Either peek(Consumer rightConsumer) { return peek(l -> { }, rightConsumer); } + /** + * Perform side-effects against a wrapped right or left value, returning back the Either unaltered. + * + * @param leftConsumer the effecting consumer for left values + * @param rightConsumer the effecting consumer for right values + * @return the Either, unaltered + */ public Either peek(Consumer leftConsumer, Consumer rightConsumer) { return flatMap(l -> { leftConsumer.accept(l); @@ -82,8 +166,17 @@ public Either peek(Consumer leftConsumer, Consumer rightConsumer) { }); } - public abstract V match(Fn1 leftFn, - Fn1 rightFn); + /** + * Given two mapping functions (one from an L to a V, one from an R to a + * V), unwrap the value stored in this Either, apply the appropriate mapping function, + * and return the result. + * + * @param leftFn the left value mapping function + * @param rightFn the right value mapping function + * @param the result type + * @return the result of applying the appropriate mapping function to the wrapped value + */ + public abstract V match(Fn1 leftFn, Fn1 rightFn); @Override public final Either fmap(Fn1 fn) { @@ -108,11 +201,32 @@ public final Either biMap(Fn1 leftFn, return match(l -> left(leftFn.apply(l)), r -> right(rightFn.apply(r))); } + /** + * Convert an {@link Optional}<R> into an Either<L, R>, supplying the left value from + * leftFn in the case of {@link Optional#empty()}. + * + * @param optional the optional + * @param leftFn the supplier to use for left values + * @param the left parameter type + * @param the right parameter type + * @return a right value of the contained optional value, or a left value of leftFn's result + */ public static Either fromOptional(Optional optional, Supplier leftFn) { return optional.>map(Either::right) .orElse(left(leftFn.get())); } + /** + * Attempt to execute the {@link CheckedSupplier}, returning its result in a right value. If the supplier throws an + * exception, apply leftFn to it, wrap it in a left value and return it. + * + * @param supplier the supplier of the right value + * @param leftFn a function mapping E to L + * @param the most contravariant exception that the supplier might throw + * @param the left parameter type + * @param the right parameter type + * @return the supplier result as a right value, or leftFn's mapping result as a left value + */ @SuppressWarnings("unchecked") public static Either trying(CheckedSupplier supplier, Fn1 leftFn) { @@ -123,14 +237,39 @@ public static Either trying(CheckedSupplier the left parameter type (the most contravariant exception that supplier might throw) + * @param the right parameter type + * @return the supplier result as a right value, or a left value of the thrown exception + */ public static Either trying(CheckedSupplier supplier) { return trying(supplier, id()); } + /** + * Static factory method for creating a left value. + * + * @param l the wrapped value + * @param the left parameter type + * @param the right parameter type + * @return a left value of l + */ public static Either left(L l) { return new Left<>(l); } + /** + * Static factory method for creating a right value. + * + * @param r the wrapped value + * @param the left parameter type + * @param the right parameter type + * @return a right value of r + */ public static Either right(R r) { return new Right<>(r); } @@ -143,8 +282,7 @@ private Left(L l) { } @Override - public V match(Fn1 leftFn, - Fn1 rightFn) { + public V match(Fn1 leftFn, Fn1 rightFn) { return leftFn.apply(l); } @@ -174,8 +312,7 @@ private Right(R r) { } @Override - public V match(Fn1 leftFn, - Fn1 rightFn) { + public V match(Fn1 leftFn, Fn1 rightFn) { return rightFn.apply(r); } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java index 995e1b4f2..aaebee9c7 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/HList.java @@ -3,8 +3,9 @@ import java.util.Objects; /** - * A heterogeneous list supporting arbitrary depth type-safety via a linearly recursive type signature. Note that due to - * its rapidly expanding type signature, specializations exist up to certain depths to minimize typing overhead. + * An immutable heterogeneous list supporting arbitrary depth type-safety via a linearly recursive type signature. Note + * that due to its rapidly expanding type signature, specializations exist up to certain depths to minimize typing + * overhead. * * @param The head element type * @param The encoded recursive tail HList type @@ -19,32 +20,116 @@ public abstract class HList> { private HList() { } + /** + * Cons an element onto the front of this HList. + * + * @param newHead the new head element + * @param the new head type + * @return the updated HList + */ public abstract HCons> cons(NewHead newHead); + /** + * Static factory method for creating empty HLists. + * + * @return an empty HList + */ public static HNil nil() { return HNil.INSTANCE; } + /** + * Static factory method for creating an HList from the given head and tail. + * + * @param head the head element + * @param tail the tail HList + * @param the head type + * @param the tail type + * @return the newly created HList + */ public static > HCons cons(Head head, Tail tail) { return new HCons<>(head, tail); } + /** + * Static factory method for creating a singleton HList. + * + * @param head the head element + * @param the head element type + * @return the singleton HList + */ public static SingletonHList singletonHList(Head head) { return new SingletonHList<>(head); } + /** + * Static factory method for creating a 2-element HList. + * + * @param _1 the head element + * @param _2 the second element + * @param <_1> the head element type + * @param <_2> the second element type + * @return the 2-element HList + * @see Tuple2 + */ + @SuppressWarnings("JavaDoc") public static <_1, _2> Tuple2<_1, _2> tuple(_1 _1, _2 _2) { return singletonHList(_2).cons(_1); } + /** + * Static factory method for creating a 3-element HList. + * + * @param _1 the head element + * @param _2 the second element + * @param _3 the third element + * @param <_1> the head element type + * @param <_2> the second element type + * @param <_3> the third element type + * @return the 3-element HList + * @see Tuple3 + */ + @SuppressWarnings("JavaDoc") public static <_1, _2, _3> Tuple3<_1, _2, _3> tuple(_1 _1, _2 _2, _3 _3) { return tuple(_2, _3).cons(_1); } + /** + * Static factory method for creating a 4-element HList. + * + * @param _1 the head element + * @param _2 the second element + * @param _3 the third element + * @param _4 the fourth element + * @param <_1> the head element type + * @param <_2> the second element type + * @param <_3> the third element type + * @param <_4> the fourth element type + * @return the 4-element HList + * @see Tuple4 + */ + @SuppressWarnings("JavaDoc") public static <_1, _2, _3, _4> Tuple4<_1, _2, _3, _4> tuple(_1 _1, _2 _2, _3 _3, _4 _4) { return tuple(_2, _3, _4).cons(_1); } + /** + * Static factory method for creating a 5-element HList. + * + * @param _1 the head element + * @param _2 the second element + * @param _3 the third element + * @param _4 the fourth element + * @param _5 the fifth element + * @param <_1> the head element type + * @param <_2> the second element type + * @param <_3> the third element type + * @param <_4> the fourth element type + * @param <_5> the fifth element type + * @return the 5-element HList + * @see Tuple5 + */ + @SuppressWarnings("JavaDoc") public static <_1, _2, _3, _4, _5> Tuple5<_1, _2, _3, _4, _5> tuple(_1 _1, _2 _2, _3 _3, _4 _4, _5 _5) { return tuple(_2, _3, _4, _5).cons(_1); } @@ -75,9 +160,8 @@ public Tail tail() { public final boolean equals(Object other) { if (other instanceof HCons) { HCons that = (HCons) other; - boolean sameHead = this.head.equals(that.head); - boolean sameTail = this.tail.equals(that.tail); - return sameHead && sameTail; + return this.head.equals(that.head) + && this.tail.equals(that.tail); } return false; } @@ -99,6 +183,9 @@ public final String toString() { public static final class HNil extends HList { private static final HNil INSTANCE = new HNil(); + private HNil() { + } + @Override public SingletonHList cons(Head head) { return new SingletonHList<>(head); diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java index cacfbecb5..f651328a8 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/SingletonHList.java @@ -5,8 +5,10 @@ import com.jnape.palatable.lambda.functions.Fn1; import com.jnape.palatable.lambda.functor.Functor; +import java.util.RandomAccess; + /** - * A singleton HList. + * A singleton HList. Supports random access. * * @param <_1> The single slot element type * @see HList @@ -15,7 +17,7 @@ * @see Tuple4 * @see Tuple5 */ -public final class SingletonHList<_1> extends HCons<_1, HNil> implements Functor<_1> { +public class SingletonHList<_1> extends HCons<_1, HNil> implements Functor<_1>, RandomAccess { SingletonHList(_1 _1) { super(_1, nil()); diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java index e44df2135..222fb1f23 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple2.java @@ -8,7 +8,7 @@ import java.util.Map; /** - * A 2-element tuple product type, implemented as a specialized HList. + * A 2-element tuple product type, implemented as a specialized HList. Supports random access. * * @param <_1> The first slot element type * @param <_2> The second slot element type @@ -18,10 +18,15 @@ * @see Tuple4 * @see Tuple5 */ -public final class Tuple2<_1, _2> extends HCons<_1, SingletonHList<_2>> implements Map.Entry<_1, _2>, Functor<_2>, Bifunctor<_1, _2> { +public class Tuple2<_1, _2> extends HCons<_1, SingletonHList<_2>> implements Map.Entry<_1, _2>, Functor<_2>, Bifunctor<_1, _2> { + + private final _1 _1; + private final _2 _2; Tuple2(_1 _1, SingletonHList<_2> tail) { super(_1, tail); + this._1 = _1; + _2 = tail.head(); } @Override @@ -29,12 +34,22 @@ public <_0> Tuple3<_0, _1, _2> cons(_0 _0) { return new Tuple3<>(_0, this); } + /** + * Retrieve the first (head) element in constant time. + * + * @return the head element + */ public _1 _1() { - return head(); + return _1; } + /** + * Retrieve the second element in constant time. + * + * @return the second element + */ public _2 _2() { - return tail().head(); + return _2; } @Override @@ -75,6 +90,14 @@ public <_1Prime, _2Prime> Tuple2<_1Prime, _2Prime> biMap(Fn1(lFn.apply(_1()), tail().fmap(rFn)); } + /** + * Static factory method for creating Tuple2s from {@link java.util.Map.Entry}s. + * + * @param entry the map entry + * @param the key parameter type, and first (head) element type + * @param the value parameter type, and second element type + * @return the newly created Tuple2 + */ public static Tuple2 fromEntry(Map.Entry entry) { return new Tuple2<>(entry.getKey(), singletonHList(entry.getValue())); } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java index 2c9d8c848..acc840e06 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple3.java @@ -6,7 +6,7 @@ import com.jnape.palatable.lambda.functor.Functor; /** - * A 3-element tuple product type, implemented as a specialized HList. + * A 3-element tuple product type, implemented as a specialized HList. Supports random access. * * @param <_1> The first slot element type * @param <_2> The second slot element type @@ -17,9 +17,16 @@ * @see Tuple4 * @see Tuple5 */ -public final class Tuple3<_1, _2, _3> extends HCons<_1, Tuple2<_2, _3>> implements Functor<_3>, Bifunctor<_2, _3> { +public class Tuple3<_1, _2, _3> extends HCons<_1, Tuple2<_2, _3>> implements Functor<_3>, Bifunctor<_2, _3> { + private final _1 _1; + private final _2 _2; + private final _3 _3; + Tuple3(_1 _1, Tuple2<_2, _3> tail) { super(_1, tail); + this._1 = _1; + _2 = tail._1(); + _3 = tail._2(); } @Override @@ -27,16 +34,31 @@ public <_0> Tuple4<_0, _1, _2, _3> cons(_0 _0) { return new Tuple4<>(_0, this); } + /** + * Retrieve the first (head) element in constant time. + * + * @return the head element + */ public _1 _1() { - return head(); + return _1; } + /** + * Retrieve the second element in constant time. + * + * @return the second element + */ public _2 _2() { - return tail()._1(); + return _2; } + /** + * Retrieve the third element in constant time. + * + * @return the third element + */ public _3 _3() { - return tail()._2(); + return _3; } @Override diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java index 208cdc553..38208b713 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple4.java @@ -6,7 +6,7 @@ import com.jnape.palatable.lambda.functor.Functor; /** - * A 4-element tuple product type, implemented as a specialized HList. + * A 4-element tuple product type, implemented as a specialized HList. Supports random access. * * @param <_1> The first slot element type * @param <_2> The second slot element type @@ -18,9 +18,18 @@ * @see Tuple3 * @see Tuple5 */ -public final class Tuple4<_1, _2, _3, _4> extends HCons<_1, Tuple3<_2, _3, _4>> implements Functor<_4>, Bifunctor<_3, _4> { +public class Tuple4<_1, _2, _3, _4> extends HCons<_1, Tuple3<_2, _3, _4>> implements Functor<_4>, Bifunctor<_3, _4> { + private final _1 _1; + private final _2 _2; + private final _3 _3; + private final _4 _4; + Tuple4(_1 _1, Tuple3<_2, _3, _4> tail) { super(_1, tail); + this._1 = _1; + _2 = tail._1(); + _3 = tail._2(); + _4 = tail._3(); } @Override @@ -28,20 +37,40 @@ public <_0> Tuple5<_0, _1, _2, _3, _4> cons(_0 _0) { return new Tuple5<>(_0, this); } + /** + * Retrieve the first (head) element in constant time. + * + * @return the head element + */ public _1 _1() { - return head(); + return _1; } + /** + * Retrieve the second element in constant time. + * + * @return the second element + */ public _2 _2() { - return tail()._1(); + return _2; } + /** + * Retrieve the third element in constant time. + * + * @return the third element + */ public _3 _3() { - return tail()._2(); + return _3; } + /** + * Retrieve the fourth element in constant time. + * + * @return the fourth element + */ public _4 _4() { - return tail()._3(); + return _4; } @Override diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java index 4da6f6a84..49cf2c29a 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Tuple5.java @@ -6,7 +6,7 @@ import com.jnape.palatable.lambda.functor.Functor; /** - * A 5-element tuple product type, implemented as a specialized HList. + * A 5-element tuple product type, implemented as a specialized HList. Supports random access. * * @param <_1> The first slot element type * @param <_2> The second slot element type @@ -19,9 +19,20 @@ * @see Tuple3 * @see Tuple4 */ -public final class Tuple5<_1, _2, _3, _4, _5> extends HCons<_1, Tuple4<_2, _3, _4, _5>> implements Functor<_5>, Bifunctor<_4, _5> { - Tuple5(_1 a, Tuple4<_2, _3, _4, _5> tail) { - super(a, tail); +public class Tuple5<_1, _2, _3, _4, _5> extends HCons<_1, Tuple4<_2, _3, _4, _5>> implements Functor<_5>, Bifunctor<_4, _5> { + private final _1 _1; + private final _2 _2; + private final _3 _3; + private final _4 _4; + private final _5 _5; + + Tuple5(_1 _1, Tuple4<_2, _3, _4, _5> tail) { + super(_1, tail); + this._1 = _1; + _2 = tail._1(); + _3 = tail._2(); + _4 = tail._3(); + _5 = tail._4(); } @Override @@ -29,24 +40,49 @@ public <_0> HCons<_0, Tuple5<_1, _2, _3, _4, _5>> cons(_0 _0) { return new HCons<>(_0, this); } + /** + * Retrieve the first (head) element in constant time. + * + * @return the head element + */ public _1 _1() { - return head(); + return _1; } + /** + * Retrieve the second element in constant time. + * + * @return the second element + */ public _2 _2() { - return tail()._1(); + return _2; } + /** + * Retrieve the third element in constant time. + * + * @return the third element + */ public _3 _3() { - return tail()._2(); + return _3; } + /** + * Retrieve the fourth element in constant time. + * + * @return the fourth element + */ public _4 _4() { - return tail()._3(); + return _4; } + /** + * Retrieve the fifth element in constant time. + * + * @return the fifth element + */ public _5 _5() { - return tail()._4(); + return _5; } @Override @@ -67,9 +103,8 @@ public <_5Prime> Tuple5<_1, _2, _3, _4, _5Prime> biMapR(Fn1 Tuple5<_1, _2, _3, _4Prime, _5Prime> biMap( - Fn1 lFn, - Fn1 rFn) { + public <_4Prime, _5Prime> Tuple5<_1, _2, _3, _4Prime, _5Prime> biMap(Fn1 lFn, + Fn1 rFn) { return new Tuple5<>(_1(), tail().biMap(lFn, rFn)); } } diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java b/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java index aa6471905..ba15852e3 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hmap/HMap.java @@ -15,7 +15,8 @@ import static java.util.Collections.singletonMap; /** - * A heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping interface. + * An immutable heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping + * interface. * * @see TypeSafeKey * @see com.jnape.palatable.lambda.adt.hlist.HList @@ -30,31 +31,76 @@ public class HMap implements Iterable> { this.table = table; } + /** + * Retrieve the value at this key. + * + * @param key the key + * @param the value type + * @return the value at this key wrapped in an {@link Optional}, or {@link Optional#empty}. + */ @SuppressWarnings("unchecked") public Optional get(TypeSafeKey key) { return Optional.ofNullable((T) table.get(key)); } - public V demand(TypeSafeKey key) { + /** + * Retrieve the value at this key, throwing a {@link NoSuchElementException} if this key is unmapped. + * + * @param key the key + * @param the value type + * @return the value at this key + * @throws NoSuchElementException if the key is unmapped + */ + public V demand(TypeSafeKey key) throws NoSuchElementException { return get(key).orElseThrow(() -> new NoSuchElementException("Demanded value for key " + key + ", but couldn't find one.")); } + /** + * Store a value for the given key. + * + * @param key the key + * @param value the value + * @param the value type + * @return the updated HMap + */ public HMap put(TypeSafeKey key, V value) { return alter(t -> t.put(key, value)); } + /** + * Store all the key/value mappings in hMap in this HMap. + * + * @param hMap the other hMap + * @return the updated HMap + */ public HMap putAll(HMap hMap) { return alter(t -> t.putAll(hMap.table)); } + /** + * Determine if a key is mapped. + * + * @param key the key + * @return true if the key is mapped; false otherwise + */ public boolean containsKey(TypeSafeKey key) { return table.containsKey(key); } + /** + * Retrieve all the mapped keys. + * + * @return an Iterable of all the mapped keys + */ public Iterable keys() { return map(Tuple2::_1, this); } + /** + * Retrieve all the mapped values. + * + * @return an Iterable of all the mapped values + */ public Iterable values() { return map(Tuple2::_2, this); } @@ -91,19 +137,57 @@ private HMap alter(Consumer> alterFn) { return new HMap(copy); } + /** + * Static factory method for creating an empty HMap. + * + * @return an empty HMap + */ public static HMap emptyHMap() { return EMPTY; } + /** + * Static factory method for creating a singleton HMap. + * + * @param key the only mapped key + * @param value the only mapped value + * @param the only mapped value type + * @return a singleton HMap + */ public static HMap singletonHMap(TypeSafeKey key, V value) { return new HMap(singletonMap(key, value)); } + /** + * Static factory method for creating an HMap from two given associations. + * + * @param key1 the first mapped key + * @param value1 the value mapped at key1 + * @param key2 the second mapped key + * @param value2 the value mapped at key2 + * @param value1's type + * @param value2's type + * @return an HMap with the given associations + */ public static HMap hMap(TypeSafeKey key1, V1 value1, TypeSafeKey key2, V2 value2) { return singletonHMap(key1, value1).put(key2, value2); } + /** + * Static factory method for creating an HMap from three given associations. + * + * @param key1 the first mapped key + * @param value1 the value mapped at key1 + * @param key2 the second mapped key + * @param value2 the value mapped at key2 + * @param key3 the third mapped key + * @param value3 the value mapped at key3 + * @param value1's type + * @param value2's type + * @param value3's type + * @return an HMap with the given associations + */ public static HMap hMap(TypeSafeKey key1, V1 value1, TypeSafeKey key2, V2 value2, TypeSafeKey key3, V3 value3) { diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java b/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java index f4d27566b..d62178132 100644 --- a/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java +++ b/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java @@ -13,6 +13,12 @@ @SuppressWarnings("unused") public interface TypeSafeKey { + /** + * Static factory method for creating a unique type-safe key + * + * @param the type of value stored at this key + * @return a unique type-safe key + */ static TypeSafeKey typeSafeKey() { return new TypeSafeKey() { }; diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java index 766d57788..a5eda64ea 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java @@ -9,43 +9,106 @@ * A function taking a single argument. This is the core function type that all other function types extend and * auto-curry with. * - * @param The input type - * @param The output type + * @param The argument type + * @param The result type */ @FunctionalInterface public interface Fn1 extends Functor, Profunctor, Function { + /** + * Invoke this function with the given argument. + * + * @param a the argument + * @return the result of the function application + */ B apply(A a); - default Fn1 then(Fn1 g) { - return fmap(g); + /** + * Left-to-right composition, such that g.then(f).apply(x) is equivalent to + * f.apply(g.apply(x)). + * + * @param f the function to invoke with this function's return value + * @param the return type of the next function to invoke + * @return a function representing the composition of this function and f + */ + default Fn1 then(Fn1 f) { + return fmap(f); } + /** + * Also left-to-right composition (sadly). + * + * @param f the function to invoke with this function's return value + * @param the return type of the next function to invoke + * @return a function representing the composition of this function and f + * @see Fn1#then(Fn1) + */ @Override - default Fn1 fmap(Fn1 g) { - return a -> g.apply(apply(a)); + default Fn1 fmap(Fn1 f) { + return a -> f.apply(apply(a)); } + /** + * Contravariantly map over the argument to this function, producing a function that takes the new argument type, + * and produces the same result. + * + * @param fn the contravariant argument mapping function + * @param the new argument type + * @return a new function from Z (the new argument type) to B (the same result) + */ @Override default Fn1 diMapL(Fn1 fn) { return (Fn1) Profunctor.super.diMapL(fn); } + /** + * Covariantly map over the return value of this function, producing a function that takes the same argument, and + * produces the new result type. + * + * @param fn the covariant result mapping function + * @param the new result type + * @return a new function from A (the same argument type) to C (the new result type) + */ @Override default Fn1 diMapR(Fn1 fn) { return (Fn1) Profunctor.super.diMapR(fn); } + /** + * Exercise both diMapL and diMapR over this function in the same invocation. + * + * @param lFn the contravariant argument mapping function + * @param rFn the covariant result mapping function + * @param the new argument type + * @param the new result type + * @return a new function from Z (the new argument type) to C (the new result type) + */ @Override - default Fn1 diMap(Fn1 lFn, Fn1 rFn) { + default Fn1 diMap(Fn1 lFn, Fn1 rFn) { return lFn.andThen(this).andThen(rFn); } + /** + * Override of {@link Function#compose(Function)}, returning an instance of Fn1 for compatibility. + * Right-to-left composition. + * + * @param before the function who's return value is this function's argument + * @param the new argument type + * @return a new function from Z (the new argument type) to B (the same result type) + */ @Override default Fn1 compose(Function before) { return z -> apply(before.apply(z)); } + /** + * Override of {@link Function#andThen(Function)}, returning an instance of Fn1 for compatibility. + * Left-to-right composition. + * + * @param after the function to invoke on this function's return value + * @param the new result type + * @return a new function from A (the same argument type) to C (the new result type) + */ @Override default Fn1 andThen(Function after) { return a -> after.apply(apply(a)); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java index 58a0c6590..5f9b6677b 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java @@ -3,7 +3,9 @@ import com.jnape.palatable.lambda.adt.hlist.Tuple2; /** - * A function taking two arguments. Auto-curried. + * A function taking two arguments. Note that defining Fn2 in terms of Fn1 provides a + * reasonable approximation of currying in the form of multiple apply overloads that take different numbers + * of arguments. * * @param The first argument type * @param The second argument type @@ -14,17 +16,40 @@ @FunctionalInterface public interface Fn2 extends Fn1> { + /** + * Invoke this function with the given arguments. + * + * @param a the first argument + * @param b the second argument + * @return the result of the function application + */ C apply(A a, B b); + /** + * Partially apply this function by passing its first argument. + * + * @param a the first argument + * @return an Fn1 that takes the second argument and returns the result + */ @Override default Fn1 apply(A a) { return (b) -> apply(a, b); } + /** + * Flip the order of the arguments. + * + * @return an Fn2 that takes the first and second arguments in reversed order + */ default Fn2 flip() { return (b, a) -> apply(a, b); } + /** + * Returns an Fn1 that takes the arguments as a Tuple2<A, B>. + * + * @return an Fn1 taking a Tuple2 + */ default Fn1, C> uncurry() { return (ab) -> apply(ab._1(), ab._2()); } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java index 91cd087d1..6efb9bb1b 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java @@ -3,7 +3,7 @@ import com.jnape.palatable.lambda.adt.hlist.Tuple2; /** - * A function taking three arguments. Auto-curried. + * A function taking three arguments. Defined in terms of Fn2, so similarly auto-curried. * * @param The first argument type * @param The second argument type @@ -15,23 +15,55 @@ @FunctionalInterface public interface Fn3 extends Fn2> { + /** + * Invoke this function with the given arguments. + * + * @param a the first argument + * @param b the second argument + * @param c the third argument + * @return the result of the function application + */ D apply(A a, B b, C c); + /** + * Partially apply this function by taking its first argument. + * + * @param a the first argument + * @return an Fn2 that takes the second and third argument and returns the result + */ @Override default Fn2 apply(A a) { return (b, c) -> apply(a, b, c); } + /** + * Partially apply this function by taking its first two arguments. + * + * @param a the first argument + * @param b the second argument + * @return an Fn1 that takes the third argument and returns the result + */ @Override default Fn1 apply(A a, B b) { return (c) -> apply(a, b, c); } + /** + * Flip the order of the first two arguments. + * + * @return an Fn3 that takes the first and second arguments in reversed order + */ @Override default Fn3 flip() { return (b, a, c) -> apply(a, b, c); } + /** + * Returns an Fn2 that takes the first two arguments as a Tuple2<A, B> and the third + * argument. + * + * @return an Fn2 taking a Tuple2 and the third argument + */ @Override default Fn2, C, D> uncurry() { return (ab, c) -> apply(ab._1(), ab._2(), c); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java index 8f7a0e427..f9c2037f4 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Predicate.java @@ -2,6 +2,8 @@ import com.jnape.palatable.lambda.functions.Fn1; +import java.util.function.Function; + /** * A specialized {@link Fn1} that returns a Boolean. * @@ -9,21 +11,67 @@ */ public interface Predicate extends Fn1, java.util.function.Predicate { + /** + * {@inheritDoc} + */ @Override default boolean test(A a) { return apply(a); } + /** + * Override of {@link Function#compose(Function)}, returning an instance of Predicate for + * compatibility. Right-to-left composition. + * + * @param before the function who's return value is this predicate's argument + * @param the new argument type + * @return a new predicate of Z (the new argument type) + */ + @Override + @SuppressWarnings("unchecked") + default Predicate compose(Function before) { + return Fn1.super.compose(before)::apply; + } + + /** + * {@inheritDoc} + */ + @Override + @SuppressWarnings("unchecked") + default Predicate diMapL(Fn1 fn) { + return Fn1.super.diMapL(fn)::apply; + } + + /** + * Override of {@link java.util.function.Predicate#and(java.util.function.Predicate)}, returning an instance of + * Predicate for compatibility. Left-to-right composition. + * + * @param other the predicate to test if this one succeeds + * @return a predicate representing the conjunction of this predicate and other + */ @Override default Predicate and(java.util.function.Predicate other) { return a -> apply(a) && other.test(a); } + /** + * Override of {@link java.util.function.Predicate#or(java.util.function.Predicate)}, returning an instance of + * Predicate for compatibility. Left-to-right composition. + * + * @param other the predicate to test if this one fails + * @return a predicate representing the disjunction of this predicate and other + */ @Override default Predicate or(java.util.function.Predicate other) { return a -> apply(a) || other.test(a); } + /** + * Override of {@link java.util.function.Predicate#negate()}, returning an instance of Predicate for + * compatibility. + * + * @return the negation of this predicate + */ @Override default Predicate negate() { return a -> !apply(a); diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java index 2593bf205..15c17a796 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java @@ -24,5 +24,12 @@ default B apply(A a) { } } + /** + * A version of {@link Fn1} that can throw checked exceptions. + * + * @param a the argument + * @return the result of the function application + * @throws Exception any exception thrown by the function application + */ B checkedApply(A a) throws Exception; } diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java index 66693ae25..b16b2d6f8 100644 --- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java +++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedSupplier.java @@ -23,5 +23,11 @@ default T get() { } } + /** + * A version of {@link Supplier#get()} that can throw checked exceptions. + * + * @return the supplied result + * @throws E any exception that can be thrown by this method + */ T checkedGet() throws E; } diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java index aed065553..906c20a8c 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Bifunctor.java @@ -5,12 +5,12 @@ import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; /** - * A dually-parametric Functor that maps covariantly over both parameters. + * A dually-parametric functor that maps covariantly over both parameters. *

* For more information, read about Bifunctors. * - * @param The type of the first parameter - * @param The type of the second parameter + * @param The type of the left parameter + * @param The type of the right parameter * @see Functor * @see Profunctor * @see com.jnape.palatable.lambda.adt.hlist.Tuple2 @@ -18,14 +18,38 @@ @FunctionalInterface public interface Bifunctor { + /** + * Covariantly map over the left parameter. + * + * @param fn the mapping function + * @param the new left parameter type + * @return a bifunctor over C (the new left parameter) and B (the same right parameter) + */ default Bifunctor biMapL(Fn1 fn) { return biMap(fn, id()); } + /** + * Covariantly map over the right parameter. For all bifunctors that are also functors, it should hold that + * biMapR(f) == fmap(f). + * + * @param fn the mapping function + * @param the new right parameter type + * @return a bifunctor over A (the same left parameter) and C (the new right parameter) + */ default Bifunctor biMapR(Fn1 fn) { return biMap(id(), fn); } - Bifunctor biMap(Fn1 lFn, - Fn1 rFn); + /** + * Dually map covariantly over both the left and right parameters. This is isomorphic to + * biMapL(lFn).biMapR(rFn). + * + * @param lFn the left parameter mapping function + * @param rFn the right parameter mapping function + * @param the new left parameter type + * @param the new right parameter type + * @return a bifunctor over Z (the new left parameter type) and C (the new right parameter type) + */ + Bifunctor biMap(Fn1 lFn, Fn1 rFn); } diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java index 6f81c7b80..2d600d433 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Functor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Functor.java @@ -19,5 +19,13 @@ @FunctionalInterface public interface Functor { + /** + * Covariantly transmute this functor's parameter using the given mapping function. Generally this method is + * specialized to return an instance of the class implementing Functor. + * + * @param fn the mapping function + * @param the new parameter type + * @return a functor over B (the new parameter type) + */ Functor fmap(Fn1 fn); } diff --git a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java index 562e003b2..aae917e55 100644 --- a/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java +++ b/src/main/java/com/jnape/palatable/lambda/functor/Profunctor.java @@ -5,13 +5,13 @@ import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id; /** - * A dually-parametric Functor that maps contravariantly over the first parameter and covariantly over the - * second. + * A dually-parametric functor that maps contravariantly over the left parameter and covariantly over the + * right. *

* For more information, read about Profunctors. * - * @param The type of the first parameter - * @param The type of the second parameter + * @param The type of the left parameter + * @param The type of the right parameter * @see Functor * @see Bifunctor * @see Fn1 @@ -19,13 +19,38 @@ @FunctionalInterface public interface Profunctor { - default Profunctor diMapL(Fn1 fn) { + /** + * Contravariantly map over the left parameter. + * + * @param fn the mapping function + * @param the new left parameter type + * @return a profunctor over Z (the new left parameter type) and C (the same right parameter type) + */ + default Profunctor diMapL(Fn1 fn) { return diMap(fn, id()); } + /** + * Covariantly map over the right parameter. For all profunctors that are also functors, it should hold that + * diMapR(f) == fmap(f). + * + * @param fn the mapping function + * @param the new right parameter type + * @return a profunctor over A (the same left parameter type) and C (the new right parameter type) + */ default Profunctor diMapR(Fn1 fn) { return diMap(id(), fn); } - Profunctor diMap(Fn1 lFn, Fn1 rFn); + /** + * Dually map contravariantly over the left parameter and covariantly over the right parameter. This is isomorphic + * to diMapL(lFn).diMapR(rFn). + * + * @param lFn the left parameter mapping function + * @param rFn the right parameter mapping function + * @param the new left parameter type + * @param the new right parameter type + * @return a profunctor over Z (the new left parameter type) and C (the new right parameter tyep) + */ + Profunctor diMap(Fn1 lFn, Fn1 rFn); } diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java index 7326e08bd..0719bd5f2 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple2Test.java @@ -6,8 +6,13 @@ import java.util.HashMap; import java.util.Map; +import static com.jnape.palatable.lambda.adt.hlist.HList.singletonHList; import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.only; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; public class Tuple2Test { @@ -39,6 +44,17 @@ public void accessors() { assertEquals((Integer) 2, tuple2._2()); } + @Test + public void randomAccess() { + SingletonHList spiedTail = spy(singletonHList("second")); + Tuple2 tuple2 = new Tuple2<>("first", spiedTail); + + verify(spiedTail, only()).head(); + tuple2._1(); + tuple2._2(); + verifyNoMoreInteractions(spiedTail); + } + @Test public void functorProperties() { assertEquals(new Tuple2<>(1, new SingletonHList<>("2")), tuple2.fmap(Object::toString)); diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java index 8f05eae76..a354a350c 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple3Test.java @@ -3,7 +3,12 @@ import org.junit.Before; import org.junit.Test; +import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; public class Tuple3Test { @@ -36,6 +41,19 @@ public void accessors() { assertEquals((Character) '3', tuple3._3()); } + @Test + public void randomAccess() { + Tuple2 spiedTail = spy(tuple("second", "third")); + Tuple3 tuple3 = new Tuple3<>("first", spiedTail); + + verify(spiedTail, times(1))._1(); + verify(spiedTail, times(1))._2(); + tuple3._1(); + tuple3._2(); + tuple3._3(); + verifyNoMoreInteractions(spiedTail); + } + @Test public void functorProperties() { assertEquals(new Tuple3<>(1, new Tuple2<>("2", new SingletonHList<>("3"))), tuple3.fmap(Object::toString)); diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java index c31e7915d..75567e324 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple4Test.java @@ -3,7 +3,12 @@ import org.junit.Before; import org.junit.Test; +import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; public class Tuple4Test { @@ -37,6 +42,21 @@ public void accessors() { assertEquals(false, tuple4._4()); } + @Test + public void randomAccess() { + Tuple3 spiedTail = spy(tuple("second", "third", "fourth")); + Tuple4 tuple4 = new Tuple4<>("first", spiedTail); + + verify(spiedTail, times(1))._1(); + verify(spiedTail, times(1))._2(); + verify(spiedTail, times(1))._3(); + tuple4._1(); + tuple4._2(); + tuple4._3(); + tuple4._4(); + verifyNoMoreInteractions(spiedTail); + } + @Test public void functorProperties() { assertEquals(new Tuple4<>(1, new Tuple3<>("2", new Tuple2<>('3', new SingletonHList<>(true)))), tuple4.fmap(x -> !x)); diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java index cb6b43771..febdb0007 100644 --- a/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java +++ b/src/test/java/com/jnape/palatable/lambda/adt/hlist/Tuple5Test.java @@ -4,7 +4,12 @@ import org.junit.Before; import org.junit.Test; +import static com.jnape.palatable.lambda.adt.hlist.HList.tuple; import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; public class Tuple5Test { @@ -39,6 +44,23 @@ public void accessors() { assertEquals((Long) 5L, tuple5._5()); } + @Test + public void randomAccess() { + Tuple4 spiedTail = spy(tuple("second", "third", "fourth", "fifth")); + Tuple5 tuple5 = new Tuple5<>("first", spiedTail); + + verify(spiedTail, times(1))._1(); + verify(spiedTail, times(1))._2(); + verify(spiedTail, times(1))._3(); + verify(spiedTail, times(1))._4(); + tuple5._1(); + tuple5._2(); + tuple5._3(); + tuple5._4(); + tuple5._5(); + verifyNoMoreInteractions(spiedTail); + } + @Test public void functorProperties() { assertEquals(new Tuple5<>(1, new Tuple4<>("2", new Tuple3<>('3', new Tuple2<>(false, new SingletonHList<>("5"))))), From 49503aeaa0af3ed493dcc69f4a469f21159fa98c Mon Sep 17 00:00:00 2001 From: jnape Date: Sun, 31 Jul 2016 17:59:43 -0500 Subject: [PATCH 11/11] [maven-release-plugin] prepare release lambda-1.3 --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index d3b197e90..215859eae 100644 --- a/pom.xml +++ b/pom.xml @@ -9,7 +9,7 @@ lambda - 1.3-SNAPSHOT + 1.3 jar Lambda

- * This function is isomorphic to a left fold over the Iterable where the head element is the starting - * accumulation value and the result is lifted into an Optional. - * - * @param The input Iterable element type, as well as the accumulation type - * @see ReduceRight - * @see com.jnape.palatable.lambda.functions.builtin.triadic.FoldLeft - */ -public final class ReduceLeft implements DyadicFunction, Iterable, Optional> { - - private ReduceLeft() { - } - - @Override - public Optional apply(DyadicFunction function, Iterable as) { - Iterator iterator = as.iterator(); - if (!iterator.hasNext()) - return Optional.empty(); - - return Optional.of(foldLeft(function, iterator.next(), () -> iterator)); - } - - public static ReduceLeft reduceLeft() { - return new ReduceLeft<>(); - } - - public static MonadicFunction, Optional> reduceLeft( - DyadicFunction function) { - return ReduceLeft.reduceLeft().apply(function); - } - - public static Optional reduceLeft(DyadicFunction function, - Iterable as) { - return ReduceLeft.reduceLeft(function).apply(as); - } -} diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java deleted file mode 100644 index 30606f018..000000000 --- a/src/main/java/com/jnape/palatable/lambda/functions/builtin/dyadic/ReduceRight.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.jnape.palatable.lambda.functions.builtin.dyadic; - -import com.jnape.palatable.lambda.functions.DyadicFunction; -import com.jnape.palatable.lambda.functions.MonadicFunction; - -import java.util.Optional; - -import static com.jnape.palatable.lambda.functions.builtin.dyadic.ReduceLeft.reduceLeft; -import static com.jnape.palatable.lambda.functions.builtin.monadic.Reverse.reverse; - -/** - * Given an Iterable of As and a {@link DyadicFunction}<A, A, A>, - * iteratively accumulate over the Iterable, returning an Optional<A> - * (if the - * Iterable is empty, the result is Optional.empty(); otherwise, the result is wrapped in - * Optional.of(). For this reason, null accumulation results are considered erroneous and will - * throw. - *