@kamilkloch It's not quite enough to use the types recommended in #891. Rather, if these are primitive operations baked into the interpreter, then we need to try / catch around them as done for ZIO.effect.

I recommend we motivate this by adding some tests. In particular, test that:

• ZIO.effectSuspend(throw TestError).either.flatMap(_ must_=== TestError)
• ZIO.effectSuspendWith(_ => throw TestError).either.flatMap(_ must_=== TestError)

I am not sure if the signatures are right (with regard to the error type). Current

effectSuspend(zio: => ZIO[R, E, A]): ZIO[R, E, A]

is as generic as possible, but effectSuspendhandles throwables, not generic Es.

On the other hand,

effectSuspend[R, A](task: => TaskR[R, A]): TaskR[R, A]

does not work for current FunctionIO.Impure implemenation (generic E):

private[zio] final class Impure[E, A, B](val apply0: A => B) extends FunctionIO[E, A, B] {
    val run: A => IO[E, B] = a =>
      IO.suspend {
        try IO.succeed[B](apply0(a))
        catch {
          case e: FunctionIOError[_] => IO.fail[E](e.unsafeCoerce[E])
        }
      }
  }

I am not sure if the signatures are right (with regard to the error type). Current

I think we can have, as you suggested, total variants that do not translate exceptions into typed error values. These can be generic for any E. Anything that catches a Throwable (the partial / non-total variants) will have to fix to Throwable.

I think we can have, as you suggested, total variants that do not translate exceptions into typed error values. These can be generic for any E. Anything that catches a Throwable (the partial / non-total variants) will have to fix to Throwable.

Thanks. Let me re-iterate to make sure I get it right. Current state in the PR:

effectSuspend(zio: => ZIO[R, E, A]): ZIO[R, E, A]
effectSuspendTotal(zio: => ZIO[R, Nothing, A]): ZIO[R, Nothing, A]

Desired state:

effectSuspend(taskr: => TaskR[R, A]): TaskR[R, A]
effectSuspendTotal(zio: => ZIO[R, E, A]): ZIO[R, E, A]

?

@kamilkloch Yes, and remember the partial variations should catch throw new Throwable (e.g.) and allow you to catchAll that error, whereas the total versions should not catch it.

Finally, remember the with variations that pass the Platform for low-level stuff...

effectSuspendTotal variations:

• ZIO

  def effectSuspendTotal[R, E, A](zio: => ZIO[R, E, A]): ZIO[R, E, A]

• RIO

  def effectSuspendTotal[R, A](rio: => RIO[R, A]): RIO[R, A]=> rio)

• UIO

  def effectSuspendTotal[A](uio: => UIO[A]): UIO[A]

• Task

  def effectSuspendTotal[A](task: => Task[A]): Task[A]

Only available in ZIO, RIO, Task:

def effectSuspend[R, A](rio: => RIO[R, A]): RIO[R, A]

@kamilkloch That looks correct to me! Don't forget the With variants that pass in the Platform.

And we need tests that:

• *Total variants cannot be "caught" with catchAll
• Partial variant (effectSuspend / effectSuspendWith) can be "caught" with catchAll

Don't forget the With variants that pass in the Platform.

It's already there :)

And we need tests that:

• *Total variants cannot be "caught" with catchAll
• Partial variant (effectSuspend / effectSuspendWith) can be "caught" with catchAll

Test for partial was there (unsafeRun(ZIO.effectSuspend[Any, Nothing](throw ExampleError).either) must_=== Left(ExampleError)). I just added the missing test for the total variant.

@jdegoes Do we miss anything? :)

@ghostdogpr @jdegoes methods are now sorted.