com.github.tonivade.purefun.instances.WriterTInstances Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2018-2020, Antonio Gabriel Muñoz Conejo 
 * Distributed under the terms of the MIT License
 */
package com.github.tonivade.purefun.instances;

import static com.github.tonivade.purefun.Precondition.checkNonNull;
import static com.github.tonivade.purefun.transformer.WriterTOf.toWriterT;

import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Kind;
import com.github.tonivade.purefun.Operator1;
import com.github.tonivade.purefun.Tuple;
import com.github.tonivade.purefun.Tuple2;
import com.github.tonivade.purefun.Witness;
import com.github.tonivade.purefun.transformer.WriterT;
import com.github.tonivade.purefun.transformer.WriterTOf;
import com.github.tonivade.purefun.transformer.WriterT_;
import com.github.tonivade.purefun.typeclasses.Monad;
import com.github.tonivade.purefun.typeclasses.MonadError;
import com.github.tonivade.purefun.typeclasses.MonadWriter;
import com.github.tonivade.purefun.typeclasses.Monoid;

public interface WriterTInstances {

  static  Monad, L>> monad(Monoid monoid, Monad monadF) {
    return WriterTMonad.instance(checkNonNull(monoid), checkNonNull(monadF));
  }

  static  MonadWriter, L>, L> monadWriter(Monoid monoid, Monad monadF) {
    return WriterTMonadWriter.instance(checkNonNull(monoid), checkNonNull(monadF));
  }

  static  MonadError, L>, E> monadError(
      Monoid monoid, MonadError monadErrorF) {
    return WriterTMonadError.instance(checkNonNull(monoid), checkNonNull(monadErrorF));
  }
}

interface WriterTMonad extends Monad, L>> {

  static  Monad, L>> instance(Monoid monoid, Monad monadF) {
    return new WriterTMonad() {

      @Override
      public Monoid monoid() { return monoid; }

      @Override
      public Monad monadF() { return monadF; }
    };
  }

  Monad monadF();
  Monoid monoid();

  @Override
  default  WriterT pure(T value) {
    return WriterT.pure(monoid(), monadF(), value);
  }

  @Override
  default  WriterT flatMap(Kind, L>, ? extends T> value,
      Function1, L>, ? extends R>> map) {
    return WriterTOf.narrowK(value).flatMap(map.andThen(WriterTOf::narrowK));
  }
}

interface WriterTMonadWriter
    extends MonadWriter, L>, L>, WriterTMonad {

  static  MonadWriter, L>, L> instance(Monoid monoid, Monad monadF) {
    return new WriterTMonadWriter() {

      @Override
      public Monoid monoid() { return monoid; }

      @Override
      public Monad monadF() { return monadF; }
    };
  }

  @Override
  default  WriterT writer(Tuple2 value) {
    return WriterT.lift(monoid(), monadF(), value);
  }

  @Override
  default  WriterT> listen(Kind, L>, ? extends A> value) {
    return value.fix(WriterTOf::narrowK).listen();
  }

  @Override
  default  WriterT pass(
      Kind, L>, Tuple2, A>> value) {
    WriterT, A>> writerT = value.fix(WriterTOf::narrowK);
    return writerT.listen().flatMap((Tuple2, A>> tuple) -> {
        Operator1 operator = tuple.get2().get1();
        A value2 = tuple.get2().get2();
      return writer(Tuple.of(operator.apply(tuple.get1()), value2)).fix(WriterTOf::narrowK);
      });
  }
}

interface WriterTMonadError
    extends MonadError, L>, E>, WriterTMonad {

  static  MonadError, L>, E> instance(
      Monoid monoid, MonadError monadErrorF) {
    return new WriterTMonadError() {

      @Override
      public Monoid monoid() { return monoid; }

      @Override
      public MonadError monadF() { return monadErrorF; }
    };
  }

  @Override
  MonadError monadF();

  @Override
  default  WriterT raiseError(E error) {
    return WriterT.writer(monoid(), monadF(),
        monadF().map(monadF().raiseError(error), a -> Tuple.of(monoid().zero(), a)));
  }

  @Override
  default  WriterT handleErrorWith(
      Kind, L>, A> value,
      Function1, L>, ? extends A>> handler) {
    return WriterT.writer(monoid(), monadF(),
        monadF().handleErrorWith(value.fix(toWriterT()).value(),
            error -> handler.apply(error).fix(WriterTOf::narrowK).value()));
  }
}