com.github.tonivade.purefun.instances.PureStreamInstances 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 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.RIO_;
import com.github.tonivade.purefun.effect.Task_;
import com.github.tonivade.purefun.effect.UIO_;
import com.github.tonivade.purefun.effect.URIO_;
import com.github.tonivade.purefun.effect.PureIO_;
import com.github.tonivade.purefun.monad.IO_;
import com.github.tonivade.purefun.stream.PureStream;
import com.github.tonivade.purefun.stream.PureStreamOf;
import com.github.tonivade.purefun.stream.PureStream_;
import com.github.tonivade.purefun.typeclasses.Applicative;
import com.github.tonivade.purefun.typeclasses.Functor;
import com.github.tonivade.purefun.typeclasses.Monad;

public interface PureStreamInstances {

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

  static  PureStream.StreamOf, Throwable>> ofPureIO() {
    return PureStream.of(PureIOInstances.monadDefer());
  }

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

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

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

  static  PureStream.StreamOf> ofURIO() {
    return PureStream.of(URIOInstances.monadDefer());
  }

  static  PureStream.StreamOf> ofRIO() {
    return PureStream.of(RIOInstances.monadDefer());
  }

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

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

interface StreamFunctor extends Functor> {

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

  @Override
  default  PureStream map(Kind, ? extends T> value, Function1 mapper) {
    return PureStreamOf.narrowK(value).map(mapper);
  }
}

interface StreamPure extends Applicative> {

  PureStream.StreamOf streamOf();

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

interface StreamMonad extends Monad>, StreamPure {

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

  @Override
  default  PureStream flatMap(Kind, ? extends T> value,
      Function1, ? extends R>> mapper) {
    return PureStreamOf.narrowK(value).flatMap(mapper.andThen(PureStreamOf::narrowK));
  }
}