com.github.tonivade.purefun.instances.StreamInstances 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 com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Kind;
import com.github.tonivade.purefun.Witness;
import com.github.tonivade.purefun.effect.EIO_;
import com.github.tonivade.purefun.effect.Task_;
import com.github.tonivade.purefun.effect.UIO_;
import com.github.tonivade.purefun.effect.ZIO_;
import com.github.tonivade.purefun.monad.IO_;
import com.github.tonivade.purefun.stream.Stream;
import com.github.tonivade.purefun.stream.StreamOf;
import com.github.tonivade.purefun.stream.Stream_;
import com.github.tonivade.purefun.typeclasses.Applicative;
import com.github.tonivade.purefun.typeclasses.Functor;
import com.github.tonivade.purefun.typeclasses.Monad;

public interface StreamInstances {

  static Stream.StreamOf ofIO() {
    return Stream.of(IOInstances.monadDefer());
  }

  static  Stream.StreamOf, Throwable>> ofZIO() {
    return Stream.of(ZIOInstances.monadDefer());
  }

  static Stream.StreamOf ofUIO() {
    return Stream.of(UIOInstances.monadDefer());
  }

  static Stream.StreamOf> ofEIO() {
    return Stream.of(EIOInstances.monadDefer());
  }

  static Stream.StreamOf ofTask() {
    return Stream.of(TaskInstances.monadDefer());
  }

  @SuppressWarnings("unchecked")
  static  Functor> functor() {
    return StreamFunctor.INSTANCE;
  }

  static  Applicative> applicative(Stream.StreamOf streamOf) {
    return StreamApplicative.instance(checkNonNull(streamOf));
  }

  static  Monad> monad(Stream.StreamOf streamOf) {
    return StreamMonad.instance(checkNonNull(streamOf));
  }
}

interface StreamFunctor extends Functor> {

  @SuppressWarnings("rawtypes")
  StreamFunctor INSTANCE = new StreamFunctor() {};

  @Override
  default  Stream map(Kind, T> value, Function1 mapper) {
    return StreamOf.narrowK(value).map(mapper);
  }
}

interface StreamPure extends Applicative> {

  Stream.StreamOf streamOf();

  @Override
  default  Stream pure(T value) {
    return streamOf().pure(value);
  }
}

interface StreamApplicative extends StreamPure {

  static  StreamApplicative instance(Stream.StreamOf streamOf) {
    return () -> streamOf;
  }

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

interface StreamMonad extends Monad>, StreamPure {

  static  StreamMonad instance(Stream.StreamOf streamOf) {
    return () -> streamOf;
  }

  @Override
  default  Stream flatMap(Kind, T> value,
      Function1, R>> mapper) {
    return StreamOf.narrowK(value).flatMap(mapper.andThen(StreamOf::narrowK));
  }
}