com.github.tonivade.purefun.stream.Suspend 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.stream;

import com.github.tonivade.purefun.Function1;
import com.github.tonivade.purefun.Function2;
import com.github.tonivade.purefun.Higher1;
import com.github.tonivade.purefun.Kind;
import com.github.tonivade.purefun.Matcher1;
import com.github.tonivade.purefun.PartialFunction1;
import com.github.tonivade.purefun.Producer;
import com.github.tonivade.purefun.Tuple2;
import com.github.tonivade.purefun.type.Option;
import com.github.tonivade.purefun.typeclasses.MonadDefer;

import static java.util.Objects.requireNonNull;

final class Suspend implements Stream {

  private final MonadDefer monad;
  private final Higher1> evalStream;

  Suspend(MonadDefer monad, Higher1> stream) {
    this.monad = requireNonNull(monad);
    this.evalStream = requireNonNull(stream);
  }

  @Override
  public Higher1> headOption() {
     return monad.flatMap(evalStream, Stream::headOption);
  }

  @Override
  public Higher1, Stream>>> split() {
    return monad.flatMap(evalStream, Stream::split);
  }

  @Override
  public Stream concat(Stream other) {
    return lazyMap(s -> s.concat(other));
  }

  @Override
  public Stream append(Higher1 other) {
    return lazyMap(s -> s.append(other));
  }

  @Override
  public Stream prepend(Higher1 other) {
    return lazyMap(s -> s.prepend(other));
  }

  @Override
  public Stream take(int n) {
    return lazyMap(s -> s.take(n));
  }

  @Override
  public Stream drop(int n) {
    return lazyMap(s -> s.drop(n));
  }

  @Override
  public Stream takeWhile(Matcher1 matcher) {
    return lazyMap(s -> s.takeWhile(matcher));
  }

  @Override
  public Stream dropWhile(Matcher1 matcher) {
    return lazyMap(s -> s.dropWhile(matcher));
  }

  @Override
  public Stream filter(Matcher1 matcher) {
    return lazyMap(s -> s.filter(matcher));
  }

  @Override
  public  Stream collect(PartialFunction1 partial) {
    return lazyMap(s -> s.collect(partial));
  }

  @Override
  public  Higher1 foldLeft(R begin, Function2 combinator) {
    return monad.flatMap(evalStream, s -> s.foldLeft(begin, combinator));
  }

  @Override
  public  Higher1 foldRight(Higher1 begin, Function2, Higher1> combinator) {
    return monad.flatMap(evalStream, s -> s.foldRight(begin, combinator));
  }

  @Override
  public Higher1 exists(Matcher1 matcher) {
    return monad.flatMap(evalStream, s -> s.exists(matcher));
  }

  @Override
  public Higher1 forall(Matcher1 matcher) {
    return monad.flatMap(evalStream, s -> s.forall(matcher));
  }

  @Override
  public  Stream map(Function1 mapper) {
    return lazyMap(s -> s.map(mapper));
  }

  @Override
  public  Stream mapEval(Function1> mapper) {
    return suspend(() -> monad.map(evalStream, s -> s.mapEval(mapper)));
  }

  @Override
  public  Stream flatMap(Function1> map) {
    return lazyMap(s -> s.flatMap(map));
  }

  @Override
  public Stream repeat() {
    return lazyMap(Stream::repeat);
  }

  @Override
  public Stream intersperse(Higher1 value) {
    return lazyMap(s -> s.intersperse(value));
  }

  @Override
  public StreamModule getModule() { throw new UnsupportedOperationException(); }

  private  Stream lazyMap(Function1, Stream> mapper) {
    return suspend(() -> monad.map(evalStream, mapper));
  }

  private  Stream suspend(Producer>> stream) {
    return new Suspend<>(monad, monad.defer(stream));
  }
}