Shouldn't this use Task instead of Arrow?

No, that would constraint it unnecessary, An Arrow[E, A] is just as much valid as a Task[A]. Though for Effect it does need to be Task, as you can't implement runAsync otherwise. For Async we can do it for any Arrow.

Arrow is more general than monad, so I don't think it's a good fit to a monad typeclass. Also, the fixed Unit input is important for performance. This has much better performance:

    def flatMap[A, B](fa: Task[A])(f: A => Task[B]): Task[E, B] =
      fa.flatMap(f)

than

    def flatMap[A, B](fa: Arrow[E, A])(f: A => Arrow[E, B]): Arrow[E, B] =
      Arrow[E].flatMap(e => fa(e).flatMap(a => f(a)(e)))

Right yeah, that's why I need to write the Effect type for Task, but we should still provide all the instances that make sense :)

For example, we also have Async instances for Kleisli[F, R, A] where F has an Async instance itself. Since Arrow is roughly equivalent to that, it stands to reason that we should provide that too :)

Arrows aren't strict so I'm not sure I understand why suspend would be necessary

It's the contract for Sync :)

you don't need to catch here, Arrow will do it

Ah, cool thanks! :)

What is the convention for these sub-projects? What is stdlib referring to? Couldn't it be just arrows-cats?

stdlib refers to the use of stdlib Future wheras arrows-twitter uses twitter Future.

I think we are at 2.12.6.

We only need cats-effect-laws for testing purposes.

Here too, I think we only need cats-mtl-laws for testing purposes, no reason to depend on it in any other context.

could it be a val?

It can't be a val because then you can't define the E type parameter :)

we could cache it and cast:

private final val catsApplicativeAskForArrowInstance: ApplicativeAsk[Arrow[Any, ?], Any] ...
implicit def catsApplicativeAskForArrow[E] = catsApplicativeAskForArrowInstance.asInstanceOf[ApplicativeAsk[Arrow[E, ?], E]]

do we need to call cb here?

The bytecode for this transformation will be large. What do you think about optimizing it? Something like

// In a stable scope
private final object ToLeft {
   private final val instance: Any => Left[Any] = Left(_)
   def apply[T]() = instance.asInstanceOf[T => Left[T]]
}

private final object ToRight {
   private final val instance: Any => Right[Any] = Right(_)
   def apply[T]() = instance.asInstanceOf[T => Right[T]]
}

and then

Arrow[Either[A, B]].flatMap { a =>
  if(a.isLeft) f(a).map(toLeft)
  else f(a).map(toRight)
}

Sorry, I'm still not sure this is a good approach. There's the performance issue, and I don't see why passing the same input to both arrows is useful other than when the arrow is a Task so the input is fixed. Could you give an example of what you couldn't express if this class used Task instead of Arrow?

Sure, together with something like ApplicativeAsk, you can define cool ReaderT style code with Arrow:

def foo[F[_]: Monad: ApplicativeAsk[?[_], Config]] = for {
  config <- ApplicativeAsk[F, Config].ask
  response <- serviceCall(config)
} yield response

Just a small example, but this is a pretty neat feature IMO and one could easily use this with e.g. http4s which only needs Sync to define the routes :)

@LukaJCB what's the type of serviceCall(config)? @alexandru could you weight in on this?

there's no need to catch here

Are you sure? If I change this line, it evaluates the line eagerly:

scala> def y(): Arrow[Int, String] = { throw new Exception(); }
y: ()arrows.stdlib.Arrow[Int,String]

scala> Arrow[Int].flatMap(y())
java.lang.Exception
  at .y(<console>:14)
  ... 36 elided

If I use my implementation instead:

scala> Arrow[Int].flatMap(i => try { y()(i) } catch { case t => Arrow.failed[String](t)(i) })
res6: arrows.stdlib.Arrow[Int,String] = <function1>

Sync#suspend requires to suspend any side-effects that occur when acquring the Arrow.

yeah, you can't pass the arrow directly since it'll evaluate the by-name param. This should do it:

Arrow[E].flatMap(e => thunk(e))

same

let's cache _ => ():

private final val toUnit: Any => Unit = _ => ()

.unsafeRunAsync(toUnit)

I took a look at the bytecode and it doesn't seem that final object will allow constant folding by the JIT compiler. Sorry for the back and forth, but could you change it to:

private final val toLeftInstance: Any => Left[Any, Nothing] = Left(_)
private final def toLeftI[T] = toLeftInstance.asInstanceOf[T => Left[T, Nothing]]

could you use map here instead? it's less expensive

Arrow[E].map(_ => thunk)