Can we name f as e?

Does this work without annotating task as Task[Int]?

No.
The return type by the compiler is [B, C, E1 >:NoSuchElementException]zio.ZIO[Any,E1,B]. 🤔

also, changing the signature to

def leftOrFailException[B, C](
    implicit ev: A <:< Either[B, C]
  ): ZIO[R, NoSuchElementException, B]

does not work too.

Actually, I tested and it looks like it infers properly - scalac says it's a ZIO[Any, NoSuchElementException, Nothing] which is accurate.

Hmm why E1 >: NoSuchElementException rather than just returning ZIO[R, NoSuchElementException, B]? Since E1 doesn't show up in the function's parameters (other than the ev2 but that doesn't influence inference, I think), this might not infer properly (or worse inferred as Any)

2 problems here - this is throwing in map and will cause a defect (rather than a typed exception), and projections are deprecated in 2.13 if I am not mistaken.

Can you fold/pattern match on the Either instead?

I agree on both points.

I am struggling with the fold/pattern matching on the '*exception' methods and opened this PR to get feedback on how to do this properly(please see my comment above).

would love some help here if possible :)

Sorry, I take back what I said about the E1 - the bounds are necessary to unify NoSuchElementException with the existing E.

This should work without right.get:

  /**
   * Returns a successful effect if the value is `Left`, or fails with a [[scala.NoSuchElementException]].
   */
  def leftOrFailException[B, C, E1 >: NoSuchElementException](
    implicit ev: A <:< Either[B, C],
    ev2: E <:< E1
  ): ZIO[R, E1, B] =
    self.foldM(
      e => ZIO.fail(ev2(e)),
      a =>
        ev(a).fold(
          ZIO.succeed(_),
          _ => ZIO.fail(new NoSuchElementException)
        )
    )

Same as with leftOrFailException

Same comments as with leftOrFailException

This method does almost the same as ZIO#get, do we really need both?

@evis, I agree with you.
I think the difference is that: someOrFailException gives you an exception in case of a failure while .get just return the unit value.

what do you think about expressing .get using someOrFailException? does that make sense?

Something like

final def get[E1 >: E, B](implicit ev: A <:< Option[B]): ZIO[R, Unit, B] =
    self.someOrFail(()).mapError(_ => ())

Good idea @dorsev

Oh, I forgot this had the E =:= Nothing constraint. I think we should leave this method alone; we're discarding an existing error here.