com.github.tonivade.purefun.stream.Suspend Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of purefun-stream Show documentation
Functional Programming Library for Java
The newest version!
/*
 * Copyright (c) 2018-2024, Antonio Gabriel Muñoz Conejo 
 * Distributed under the terms of the MIT License
 */
package com.github.tonivade.purefun.stream;

import static com.github.tonivade.purefun.core.Precondition.checkNonNull;

import com.github.tonivade.purefun.Kind;

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

public final class Suspend, T> implements PureStream {

  private final MonadDefer monad;
  private final Kind> evalStream;

  Suspend(MonadDefer monad, Kind> stream) {
    this.monad = checkNonNull(monad);
    this.evalStream = checkNonNull(stream);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  @Override
  public  PureStream flatMap(Function1, ? extends R>> map) {
    return lazyMap(s -> s.flatMap(map));
  }

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

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

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

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