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

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

import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Kind;
import com.github.tonivade.purefun.Producer;
import com.github.tonivade.purefun.type.Eval;
import com.github.tonivade.purefun.type.EvalOf;
import com.github.tonivade.purefun.type.Eval_;
import com.github.tonivade.purefun.type.Try;
import com.github.tonivade.purefun.typeclasses.Applicative;
import com.github.tonivade.purefun.typeclasses.Comonad;
import com.github.tonivade.purefun.typeclasses.Defer;
import com.github.tonivade.purefun.typeclasses.Functor;
import com.github.tonivade.purefun.typeclasses.Monad;
import com.github.tonivade.purefun.typeclasses.MonadError;
import com.github.tonivade.purefun.typeclasses.MonadThrow;

public interface EvalInstances {

  static Functor functor() {
    return EvalFunctor.INSTANCE;
  }

  static Applicative applicative() {
    return EvalApplicative.INSTANCE;
  }

  static Monad monad() {
    return EvalMonad.INSTANCE;
  }

  static MonadError monadError() {
    return EvalMonadError.INSTANCE;
  }

  static MonadThrow monadThrow() {
    return EvalMonadThrow.INSTANCE;
  }

  static Comonad comonad() {
    return EvalComonad.INSTANCE;
  }

  static Defer defer() {
    return EvalDefer.INSTANCE;
  }
}

interface EvalFunctor extends Functor {

  EvalFunctor INSTANCE = new EvalFunctor() {};

  @Override
  default  Kind map(Kind value, Function1 mapper) {
    return EvalOf.narrowK(value).map(mapper);
  }
}

interface EvalPure extends Applicative {

  @Override
  default  Kind pure(T value) {
    return Eval.now(value);
  }
}

interface EvalApplicative extends EvalPure {

  EvalApplicative INSTANCE = new EvalApplicative() {};

  @Override
  default  Kind ap(Kind value, 
      Kind> apply) {
    return EvalOf.narrowK(value).flatMap(t -> EvalOf.narrowK(apply).map(f -> f.apply(t)));
  }
}

interface EvalMonad extends EvalPure, Monad {

  EvalMonad INSTANCE = new EvalMonad() {};

  @Override
  default  Kind flatMap(Kind value, Function1> map) {
    return EvalOf.narrowK(value).flatMap(map.andThen(EvalOf::narrowK));
  }
}

interface EvalMonadError extends EvalMonad, MonadError {

  EvalMonadError INSTANCE = new EvalMonadError() {};

  @Override
  default  Kind raiseError(Throwable error) {
    return Eval.raiseError(error);
  }

  @Override
  default  Kind handleErrorWith(
      Kind value, Function1> handler) {
    Eval> attempt = Eval.always(() -> Try.of(value.fix(EvalOf::narrowK)::value));
    return attempt.flatMap(try_ -> try_.fold(handler.andThen(EvalOf::narrowK), Eval::now));
  }
}

interface EvalMonadThrow extends EvalMonadError, MonadThrow {

  EvalMonadThrow INSTANCE = new EvalMonadThrow() {};
}

interface EvalComonad extends EvalFunctor, Comonad {

  EvalComonad INSTANCE = new EvalComonad() {};

  @Override
  default  Kind coflatMap(Kind value, Function1, ? extends B> map) {
    return Eval.later(() -> map.apply(value));
  }

  @Override
  default  A extract(Kind value) {
    return EvalOf.narrowK(value).value();
  }
}

interface EvalDefer extends Defer {

  EvalDefer INSTANCE = new EvalDefer() {};

  @Override
  default  Kind defer(Producer> defer) {
    return Eval.defer(defer.map(EvalOf::narrowK));
  }
}