What do you think about not using a for-comprehension and use local vals for these and avoid all the unnecessary maps?

I'm not sure to understand your suggestion 🤔

AFAIR, using v = ... in a for-comprehension doesn't add any additional map call:

for {
  a <- ZIO.succeed("a")
  b = "b"
  c = "c"
  d <- ZIO.succeed("d")
} yield (a, b, c, d)

should produce (something close to):

ZIO
  .succeed("a")
  .flatMap { a => 
    val b = "b"
    val c = "c"
    ZIO.succeed("d").map(d => (a, b, c, d))
  }

no? 🤔

Unfortunately, no :( It's Scala version-specific, but in Scala 3 it will produce something along these lines:

ZIO
  .succeed("a")
  .map { a => 
   
    val b = "b"
    val c = "c"
    (a, b, c)
  }.flatMap { case (a, b, c) =>
    ZIO.succeed("d").map(d => (a, b, c, d))
  }

I think in Scala 2 it's very similar or even worse

Is your val suggestion looking something like this:

(SingleProducerAsyncInput.make[InErr, InElem, InDone] <*> ZIO.fiberId).flatMap { case (input, fiberId) =>
        val incoming       = ZChannel.fromInput(input)
        val n0             = n.toLong
        val bufferSize0    = bufferSize
        val mergeStrategy0 = mergeStrategy
        val outgoing =
          Queue.unsafe.bounded[ZIO[Env, Either[OutErr, OutDone], OutElem]](bufferSize0, fiberId)(Unsafe.unsafe)
        val cancelers   = Queue.unsafe.unbounded[Promise[Nothing, Unit]](fiberId)(Unsafe.unsafe)
        val lastDone    = Ref.unsafe.make[Option[OutDone]](None)(Unsafe.unsafe)
        val errorSignal = Promise.unsafe.make[Nothing, Unit](fiberId)(Unsafe.unsafe)
        val permits     = Semaphore.unsafe.make(n0)(Unsafe.unsafe)

        for {
          _          <- scope.addFinalizer(outgoing.shutdown)
          _          <- scope.addFinalizer(cancelers.shutdown)
          ...
}

? 🤔

@kyri-petrou Made an attempt here: #9387 (Merge in the current PR)

LMKWYT

Maybe we should use just use *> here

Done

As I was writing this, I felt like the toPull stuff should pull chunks instead of single elements. The cost is a little bit of housekeeping for error handling. The chunk is already somewhere in memory for the by-element pull, so it makes no difference for correctness, however it makes a huge difference for performance.

I'm a bit busy right now. I'll explore your idea later. Thanks for your review! 🙂

Edit:
Took 2s to have a look if we were able to have a Chunk[A] here but I didn't see how because toPullInAlt returns a ZIO[Env, Either[OutErr, OutDone], OutElem] and not ZIO[Env, Either[OutErr, OutDone], Chunk[OutElem]] 🤔

Could you make give it a try on top of my PR, please?

I had a look, I think to have any real effect we will need chunk-aware channels and update the pipelines:

    new ZPipeline(
      ZChannel
        .identity[Nothing, Chunk[In], Any]
        .concatMap(ZChannel.writeChunk(_))
        .mapOutZIOPar(n, bufferSize)(f)
        .mapOut(Chunk.single)
    )

to something like:

new ZPipeline(
      ZChannel
        .identity[Nothing, Chunk[In], Any]
        .mapOutChunkZIOPar(n, bufferSize)(f)
    )

with the caveat that it breaks chunk structure.

final def mapOutChunkZIOPar[Env1 <: Env, OutErr1 >: OutErr, InElem0, OutElem0, OutElem2](n: Int, bufferSize: Int = 16)(
      f: OutElem0 => ZIO[Env1, OutErr1, OutElem2]
)(implicit
      ev0: Chunk[InElem0] <:< InElem,
      ev1: OutElem <:< Chunk[OutElem0],
      trace: Trace
): ZChannel[Env1, InErr, Chunk[InElem0], InDone, OutErr1, Chunk[OutElem2], OutDone] = ???

Let's do this in another PR when this one is done. It's already a complex one.

by the by, I think this could be

then consumer can avoid the flatten and just pattern match:

outgoing.take.map {
  case s: Success[OutElem] => ZChannel.write(s.value) *> write
  case f: Failure[Either[OutErr, OutDone]] => ...
}

Thanks for spotting this! Change done :)

We could go even further and use a specialized data structure which could only be something like:

sealed trait Result[V, E, F]
object Result {
  final case class Value[V](v: V) extends Result[V, Nothing, Nothing]
  final case class Error[E](e: E) extends Result[Nothing, E, Nothing]
  final case class Fatal[E](e: E) extends Result[Nothing, Nothing, E]
}

That'd be more lightweight than Exit[Either[OutErr, OutDone], OutElem].

I'll give it a try

Edit:
Made a POC with this Result idea: #9445
Please let me know what you think :)

Nice one 👌 Another iteration on this that was exploited previously is to avoid wrapping the OutElem values, turning the queue elements into OutElem | Result.

Does OutElem | Result work with Scala2? 🤔

2 minor comments here:

1. To keep things consistent, add an implicit unsafe: Unsafe requirement for this method. This way you won't need to pass it explicitly below either
2. Change the implementation of SingleProducerAsyncInput.make to ZIO.fiberIdWith(unsafe.make(_)(trace, Unsafe))

Done.

I removed the implicit trace: Trace from the unsafe.make function to make it consistent with Promise.unsafe.make, etc.

Do we need these methods? Can't we use the apply method of the case classes directly?

No we don't :)

You don't need to suspend here, ZIO.fiberIdWith already takes care of that

Done

I'm really reluctant on passing null to anything that can end up in a ZIO effect containing a null value. I think it's better to use AtomicReference(null) directly

Done. Please have a look. I made the choice to wrap the usage of the AtomicReference in ZIO.succeed and not in Exit.succeed to avoid executing the wrapped code at the wrong moment in time. I can be wrong tho 🤔

Might be unnecessary indeed but better be safe than sorry on that front

Very minor: You can use Unsafe instead of Unsafe.unsafe

Done

@kyri-petrou I wonder if we shouldn't wrap these 2 calls in an ZIO.uninterruptible 🤔