- WriterT#pure now has direct access to embedded monad's pure

- EitherMatcher#isLeftOf/isRightOf for equality matching
- updating CHANGELOG

Author: jnape

CHANGELOG.md

@@ -1,14 +1,23 @@
 # Change Log
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## [Unreleased]
 
+### Changed
+- `Absent` folds short-circuit on the first `nothing()`
+- `EitherMatcher#isLeftThat/isRightThat` support contravariant bounds on their delegates
+
 ### Added
+- `IterateT#runStep`, a method used to run a single step of an IterateT without the contractual guarantee of emitting a
+  value or reaching the end
+- `These#fromMaybes :: Maybe a -> Maybe b -> Maybe (These a b)`
+- `EitherMatcher#isLeftOf/isRightOf` for asserting equality
 
-- `IterateT#runStep`, a method used to run a single step of an IterateT without the contractual
-  guarantee of emitting a value or reaching the end
+### Fixed
+- `WriterT` now keeps an immediate reference to the embedded monad's `pure`
 
 ## [5.3.0] - 2020-12-07
 

src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/WriterT.java

@@ -34,9 +34,12 @@ public final class WriterT<W, M extends MonadRec<?, M>, A> implements
         MonadWriter<W, A, WriterT<W, M, ?>>,
         MonadT<M, A, WriterT<W, M, ?>, WriterT<W, ?, ?>> {
 
+    private final Pure<M>                                                     pureM;
     private final Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A, W>, M>> writerFn;
 
-    private WriterT(Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A, W>, M>> writerFn) {
+    private WriterT(Pure<M> pureM,
+                    Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A, W>, M>> writerFn) {
+        this.pureM    = pureM;
         this.writerFn = writerFn;
     }
 
@@ -82,15 +85,15 @@ public <MW extends MonadRec<W, M>> MW execWriterT(Monoid<W> monoid) {
      */
     @Override
     public <B> WriterT<W, M, Tuple2<A, B>> listens(Fn1<? super W, ? extends B> fn) {
-        return new WriterT<>(writerFn.fmap(m -> m.fmap(into((a, w) -> both(both(constantly(a), fn), id(), w)))));
+        return new WriterT<>(pureM, writerFn.fmap(m -> m.fmap(into((a, w) -> both(both(constantly(a), fn), id(), w)))));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public WriterT<W, M, A> censor(Fn1<? super W, ? extends W> fn) {
-        return new WriterT<>(writerFn.fmap(mt -> mt.fmap(t -> t.fmap(fn))));
+        return new WriterT<>(pureM, writerFn.fmap(mt -> mt.fmap(t -> t.fmap(fn))));
     }
 
     /**
@@ -107,7 +110,7 @@ public <B, N extends MonadRec<?, N>> WriterT<W, N, B> lift(MonadRec<B, N> mb) {
     @Override
     public <B> WriterT<W, M, B> trampolineM(
             Fn1<? super A, ? extends MonadRec<RecursiveResult<A, B>, WriterT<W, M, ?>>> fn) {
-        return new WriterT<>(monoid -> runWriterT(monoid).trampolineM(into((a, w) -> fn.apply(a)
+        return new WriterT<>(pureM, monoid -> runWriterT(monoid).trampolineM(into((a, w) -> fn.apply(a)
                 .<WriterT<W, M, RecursiveResult<A, B>>>coerce()
                 .runWriterT(monoid).fmap(t -> t.fmap(monoid.apply(w)))
                 .fmap(into((aOrB, w_) -> aOrB.biMap(a_ -> tuple(a_, w_), b -> tuple(b, w_)))))));
@@ -126,15 +129,15 @@ public <B> WriterT<W, M, B> fmap(Fn1<? super A, ? extends B> fn) {
      */
     @Override
     public <B> WriterT<W, M, B> pure(B b) {
-        return new WriterT<>(m -> runWriterT(m).pure(tuple(b, m.identity())));
+        return new WriterT<>(pureM, m -> pureM.apply(tuple(b, m.identity())));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public <B> WriterT<W, M, B> flatMap(Fn1<? super A, ? extends Monad<B, WriterT<W, M, ?>>> f) {
-        return new WriterT<>(monoid -> writerFn.apply(monoid)
+        return new WriterT<>(pureM, monoid -> writerFn.apply(monoid)
                 .flatMap(into((a, w) -> f.apply(a).<WriterT<W, M, B>>coerce().runWriterT(monoid)
                         .fmap(t -> t.fmap(monoid.apply(w))))));
     }
@@ -144,7 +147,7 @@ public <B> WriterT<W, M, B> flatMap(Fn1<? super A, ? extends Monad<B, WriterT<W,
      */
     @Override
     public <B> WriterT<W, M, B> zip(Applicative<Fn1<? super A, ? extends B>, WriterT<W, M, ?>> appFn) {
-        return new WriterT<>(monoid -> runWriterT(monoid)
+        return new WriterT<>(pureM, monoid -> runWriterT(monoid)
                 .zip(appFn.<WriterT<W, M, Fn1<? super A, ? extends B>>>coerce().runWriterT(monoid)
                              .fmap(into((f, y) -> into((a, x) -> tuple(f.apply(a), monoid.apply(x, y)))))));
     }
@@ -196,7 +199,7 @@ public static <W, M extends MonadRec<?, M>> WriterT<W, M, Unit> tell(MonadRec<W,
      * @return the {@link WriterT}
      */
     public static <W, M extends MonadRec<?, M>, A> WriterT<W, M, A> listen(MonadRec<A, M> ma) {
-        return new WriterT<>(monoid -> ma.fmap(a -> tuple(a, monoid.identity())));
+        return new WriterT<>(Pure.of(ma), monoid -> ma.fmap(a -> tuple(a, monoid.identity())));
     }
 
     /**
@@ -209,7 +212,7 @@ public static <W, M extends MonadRec<?, M>, A> WriterT<W, M, A> listen(MonadRec<
      * @return the {@link WriterT}
      */
     public static <W, M extends MonadRec<?, M>, A> WriterT<W, M, A> writerT(MonadRec<Tuple2<A, W>, M> maw) {
-        return new WriterT<>(constantly(maw));
+        return new WriterT<>(Pure.of(maw), constantly(maw));
     }
 
     /**

src/test/java/testsupport/matchers/EitherMatcher.java

@@ -10,6 +10,7 @@
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 import static com.jnape.palatable.lambda.io.IO.io;
 import static org.hamcrest.CoreMatchers.anything;
+import static org.hamcrest.CoreMatchers.equalTo;
 
 public final class EitherMatcher<L, R> extends TypeSafeMatcher<Either<L, R>> {
     private final Either<Matcher<? super L>, Matcher<? super R>> matcher;
@@ -53,11 +54,19 @@ public static <L, R> EitherMatcher<L, R> isLeft() {
         return isLeftThat(anything());
     }
 
+    public static <L, R> EitherMatcher<L, R> isLeftOf(L l) {
+        return isLeftThat(equalTo(l));
+    }
+
     public static <L, R> EitherMatcher<L, R> isRightThat(Matcher<? super R> rMatcher) {
         return new EitherMatcher<>(right(rMatcher));
     }
 
     public static <L, R> EitherMatcher<L, R> isRight() {
         return isRightThat(anything());
     }
+
+    public static <L, R> EitherMatcher<L, R> isRightOf(R r) {
+        return isRightThat(equalTo(r));
+    }
 }