effectful | A syntax for type-safe effectful computations in Scala | Functional Programming library

Perhaps like this:

I ultimately found the solution by reading through the source code for ZIO.effectAsyncM, specifically noting its reference to ZIO.runtime[R]:

AVA will consider unhandled rejections in test files to be a failure. You'd have to run your code "elsewhere", being a child process or worker thread.

I want to ensure that my library is robust against users' callbacks causing an unhandled rejection.

IMHO that's your users problem. If your library calls user provided code and you're awaiting a promise return value you could try / catch that error, but arguably letting the program crash is perfectly valid.

First, the definition of your array monad transformer is wrong.

What you need is unsafePerformEffect - it will execute the effect in a transparent way and return its result as a pure value.

Of course. Aside from a couple JS primitives (*, +, Number, and String) to demonstrate functionality, below you will only see:

1. variables
2. lambda abstractions
3. applications

I'm not a Haskell programmer but from the type of eval (Div x y) it seems be that of Maybe(Maybe Int) - which can simply be squashed, no? (Something like a flatten in Scala or join in Haskell). What really is the issue here? … the only issue here is the return type which can be transformed appropriately

This is the key issue! ‘Squashing’ is a fundamentally monadic operation — in fact, the type signature of join is join :: Monad m => m (m a) -> m a. If you restrict yourself to the applicative methods pure and (<*>), there is no way to implement this, but it becomes easy if you let yourself use (>>=) as well. Sure, you can easily implement flattenMaybe :: Maybe (Maybe a)) -> Maybe a without using monads, but that defeats the purpose of concepts like Applicative and Monad, which should be applicable to a wide range of types, not just Maybe.

Irrespective of whether x,y are Just(s)/Nothing(s) it seems safediv will correctly evaluate - the only issue here is the return type which can be transformed appropriately. How exactly does the author go from his argument to this conclusion is what I'm having a hard time understanding.

...applicative style restricts restricts us to applying pure functions to effectful arguments

Also, why does paragraph marked (X) above make that claim when the problem just seems to be or return type misalignment.

The idea here is this. Let’s say you have two functions, and two values:

First you need to convert the Sequence to SequenceK then you can use the sequence function to do that.

Let me try to explain.

If you have a look at what ZEnv is it's an alias for Clock with Console with System with Random with Blocking. So, when you started implementing def run(args: List[String]): ZIO[ZEnv, Nothing, Int] zio already provided you with these capabilities.

Your app variable signature has a return type of zio with environment Console with System with Logger - one thing that stands out is a Logger capability. It's not standard so ZIO can't provide it for you. You have to provide it yourself.

That's what you did using .provideSome[Logger] - you eliminated one of the capabilities from environment requirements making it type compatible with the standard: