Fix semantics of provide and improve type inference
#597
Conversation
| type Task[+A] = ZIO[Any, Throwable, A] | ||
| type UIO[+A] = ZIO[Any, Nothing, A] | ||
|
|
||
| implicit class ZIOInvarant[R, E, A](val self: ZIO[R, E, A]) extends AnyVal { |
There was a problem hiding this comment.
typo in Invariant
Also, I think that if you put it in the ZIO companion object, it won't need to be imported.
|
I can't see how using EDIT: I was thinking about implicit case class, like |
|
@LGLO Did you see if we can fix by some other means? Sorry overnight 17 pull requests appeared and I am way behind on reviews. Will do more tomorrow. My other idea is to have a ZIO.bracket which takes ALL parameters at once. Then the "syntax sugar" method simply delegates to this one. This way if you have it in a hot path, you just use the uncurried form... |
|
@jdegoes I made this uncurried version but TBH I don't really like it if was the only version available. Having both looks good to me. Is |
|
@LGLO Can you submit a pull request to my pull request? 😄
|
|
Happy to help, but tomorrow, if that isn't a problem.
niedz., 3 mar 2019, 22:45: John A. De Goes <[email protected]>
napisał(a):
… @LGLO <https://github.com/LGLO> Can you submit a pull request to my pull
request? 😄
ZIOInvariant improves type inference by eliminating one layer of widening
(if we put it onto ZIO directly, then we have to widen all parameters).
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<#597 (comment)>,
or mute the thread
<https://github.com/notifications/unsubscribe-auth/ACkc0SMkJ70tSnlUQaCD8lxOIG6wOaAOks5vTEJugaJpZM4bbKB5>
.
|
| * Adds an effect to consumption of every element of the stream. | ||
| */ | ||
| final def withEffect[R1 <: R, E1 >: E](f: A => ZIO[R1, E1, Unit]): Stream[R1, E1, A] = | ||
| final def tap[R1 <: R, E1 >: E](f: A => ZIO[R1, E1, Unit]): Stream[R1, E1, A] = |
|
|
||
| final def withEffect[R1 <: R, E1 >: E](f0: A => ZIO[R1, E1, Unit]): StreamChunk[R1, E1, A] = | ||
| StreamChunk(chunks.withEffect[R1, E1] { as => | ||
| final def tap[R1 <: R, E1 >: E](f0: A => ZIO[R1, E1, Unit]): StreamChunk[R1, E1, A] = |
| * result is either succeeded with a value `A`, or failed with a `Cause[E]`. | ||
| */ | ||
| sealed abstract class Exit[+E, +A] extends Product with Serializable { self => | ||
| sealed trait Exit[+E, +A] extends Product with Serializable { self => |
There was a problem hiding this comment.
Interesting, why the change? I thought abstract classes generate more efficient bytecode most of the time.
There was a problem hiding this comment.
We dropped Scala 2.11. The main reason for abstract class is to avoid breaking backward binary compatibility on adding a method with a default implementation.
| * effects of this effect. | ||
| */ | ||
| final def const[B](b: => B): ZIO[R, E, B] = self.map(_ => b) | ||
| final def const[B](b: => B): ZIO[R, E, B] = self map (_ => b) |
| } | ||
|
|
||
| final def seq[E1 >: E, C](that: Sink[R, E1, A, A, C]): Sink[R, E1, A, A, (B, C)] = | ||
| final def zip[E1 >: E, C](that: Sink[R, E1, A, A, C]): Sink[R, E1, A, A, (B, C)] = |
There was a problem hiding this comment.
We could also allow narrowing of R here. I'll open a separate issue for this
This is mainly to fix semantics of
providewhich was incorrectly using "last one wins" instead of "scoped provision". However, I also improved type inference.