hmm
right I see
because if resource life is always uncancelable it could get tied in a knot potentially
yes?
you almost always want those to be cancelable
the question is whether you need to explicitly say
restore around them, or not
Haskell says no, and it blesses some ops as interruptible even inside
mask (which the uncancelable we're discussing)
I'm saying that regardless of the operation, if you want interruption you need to call
restore
that's especially true when nesting these sections
it also seems like ref/deferred/semaphore usage is already an area where you really need expertise
semaphore less so
anyway, I'd highly recommend going to the start of this conversation here https://gitter.im/typelevel/cats-effect?at=5d9d0b55874aeb2d2311389f
I feel like no matter what the answer there will need to be some blog posts and cheat sheets and doc tests...
my takeaway from skimming through that conversation is a big "it's really complicated" :D
@djspiewak
well like I said, I'm more than happy to share the prototype experiment results, design notes, and open questions if people are interested in taking a whack at it :-) PRs very much welcome. If no one else gets to it in the coming months, I'm sure I or someone else will implement it in the 2.x timeline
I would love to try it. I want to have it in Monix but I feel a little bit powerless, not even knowing how to start. :D I have a plenty of free time though and I'm familiar with internals. I would be happy to attempt it for cats.effect.IO first and then port to Monix. I don't get my hopes up but at the very least I might learn something in the process
object IORepl {
implicit class IOOps[A](io: IO[A]) extends AnyVal {
def yolo: A = io.unsafeRunSync()
}
implicit val ec: ExecutionContext = ExecutionContext.global
implicit val timer: Timer[IO] = IO.timer(ec)
implicit val cs: ContextShift[IO] = IO.contextShift(ec)
}
import IORepl._
with
def run(args: List[String]) = ExitCode.Success.pure[IO]
and save the typing of those implicits
object Playground extends IOApp {
def run(args: List[String]) = ExitCode.Success.pure[IO]
implicit class Runner[A](s: Stream[IO, A]) {
def yolo: Unit = s.compile.drain.unsafeRunSync
def yoloV: Vector[A] = s.compile.toVector.unsafeRunSync
}
// put("hello").to[F]
def put[A](a: A): IO[Unit] = IO(println(a))
}
this is my standard playground
probably also worth a
val blocker = Blocker.etc(global)
put is nice
I never end up doing the repl
I just write unit tests if I'm not sure what something will do :)
because that's always clearly the best method :hurtrealbad:
:D
brainpiler
often gets close enough ;)
scastie if I'm stuck
or rather, I ask them to put it in scastie if I'm stuck :laughing:
Delegation :sparkles:
I needs my IDE