-
Notifications
You must be signed in to change notification settings - Fork 508
/
MonadCancelSyntax.scala
67 lines (52 loc) · 2.06 KB
/
MonadCancelSyntax.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/*
* Copyright 2020-2024 Typelevel
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cats.effect.kernel.syntax
import cats.effect.kernel.{MonadCancel, Outcome}
trait MonadCancelSyntax {
implicit def monadCancelOps_[F[_], A](
wrapped: F[A]
): MonadCancelOps_[F, A] =
new MonadCancelOps_(wrapped)
implicit def monadCancelOps[F[_], A, E](
wrapped: F[A]
)(implicit F: MonadCancel[F, E]): MonadCancelOps[F, A, E] = {
val _ = F
new MonadCancelOps(wrapped)
}
}
final class MonadCancelOps_[F[_], A] private[syntax] (private val wrapped: F[A])
extends AnyVal {
def forceR[B](fb: F[B])(implicit F: MonadCancel[F, _]): F[B] =
F.forceR(wrapped)(fb)
def !>[B](fb: F[B])(implicit F: MonadCancel[F, _]): F[B] =
forceR(fb)
def uncancelable(implicit F: MonadCancel[F, _]): F[A] =
F.uncancelable(_ => wrapped)
def onCancel(fin: F[Unit])(implicit F: MonadCancel[F, _]): F[A] =
F.onCancel(wrapped, fin)
def guarantee(fin: F[Unit])(implicit F: MonadCancel[F, _]): F[A] =
F.guarantee(wrapped, fin)
def bracket[B](use: A => F[B])(release: A => F[Unit])(implicit F: MonadCancel[F, _]): F[B] =
F.bracket(wrapped)(use)(release)
}
final class MonadCancelOps[F[_], A, E] private[syntax] (private val wrapped: F[A])
extends AnyVal {
def guaranteeCase(fin: Outcome[F, E, A] => F[Unit])(implicit F: MonadCancel[F, E]): F[A] =
F.guaranteeCase(wrapped)(fin)
def bracketCase[B](use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit])(
implicit F: MonadCancel[F, E]): F[B] =
F.bracketCase(wrapped)(use)(release)
}