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

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

import com.github.tonivade.purefun.Consumer1;
import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Higher1;
import com.github.tonivade.purefun.Instance;
import com.github.tonivade.purefun.Producer;
import com.github.tonivade.purefun.typeclasses.Applicative;
import com.github.tonivade.purefun.typeclasses.Bracket;
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.MonadDefer;
import com.github.tonivade.purefun.typeclasses.MonadError;
import com.github.tonivade.purefun.typeclasses.MonadThrow;
import com.github.tonivade.purefun.typeclasses.Reference;
import com.github.tonivade.purefun.zio.ZIO;

public interface ZIOInstances {

  static  Functor, E>> functor() {
    return new ZIOFunctor() {};
  }

  static  Applicative, E>> applicative() {
    return new ZIOApplicative() {};
  }

  static  Monad, E>> monad() {
    return new ZIOMonad() {};
  }

  static  MonadError, E>, E> monadError() {
    return new ZIOMonadError() {};
  }

  static  MonadThrow, Throwable>> monadThrow() {
    return new ZIOMonadThrow() { };
  }

  static  MonadDefer, Throwable>> monadDefer() {
    return new ZIOMonadDefer() { };
  }

  static  Reference, Throwable>, A> ref(A value) {
    return Reference.of(monadDefer(), value);
  }
}

@Instance
interface ZIOFunctor extends Functor, E>> {

  @Override
  default  ZIO
          map(Higher1, E>, A> value, Function1 map) {
    return ZIO.narrowK(value).map(map);
  }
}

@Instance
interface ZIOPure extends Applicative, E>> {

  @Override
  default  ZIO pure(A value) {
    return ZIO.pure(value);
  }
}

@Instance
interface ZIOApplicative extends ZIOPure {

  @Override
  default  ZIO
          ap(Higher1, E>, A> value,
             Higher1, E>, Function1> apply) {
    return ZIO.narrowK(apply).flatMap(map -> ZIO.narrowK(value).map(map));
  }
}

@Instance
interface ZIOMonad extends ZIOPure, Monad, E>> {

  @Override
  default  ZIO
          flatMap(Higher1, E>, A> value,
                  Function1, E>, B>> map) {
    return ZIO.narrowK(value).flatMap(map.andThen(ZIO::narrowK));
  }
}

@Instance
interface ZIOMonadError extends ZIOMonad, MonadError, E>, E> {

  @Override
  default  ZIO raiseError(E error) {
    return ZIO.raiseError(error);
  }

  @Override
  default  ZIO
          handleErrorWith(Higher1, E>, A> value,
                          Function1, E>, A>> handler) {
    // XXX: java8 fails to infer types, I have to do this in steps
    Function1> mapError = handler.andThen(ZIO::narrowK);
    Function1> map = ZIO::pure;
    ZIO zio = ZIO.narrowK(value);
    return zio.foldM(mapError, map);
  }
}

@Instance
interface ZIOMonadThrow
    extends ZIOMonadError,
            MonadThrow, Throwable>> { }

@Instance
interface ZIODefer extends Defer, Throwable>> {

  @Override
  default  ZIO
          defer(Producer, Throwable>, A>> defer) {
    return ZIO.defer(() -> defer.andThen(ZIO::narrowK).get());
  }
}

@Instance
interface ZIOBracket extends Bracket, Throwable>> {

  @Override
  default  ZIO
          bracket(Higher1, Throwable>, A> acquire,
                  Function1, Throwable>, B>> use,
                  Consumer1 release) {
    return ZIO.bracket(acquire.fix1(ZIO::narrowK), use.andThen(ZIO::narrowK), release);
  }
}

@Instance
interface ZIOMonadDefer
    extends MonadDefer, Throwable>>,
            ZIOMonadThrow,
            ZIODefer,
            ZIOBracket { }