Skip to content

Commit 552284e

Browse files
KacperFKorbanKacperFKorban
authored
Merge pull request #25 from VirtusLab/more-instances
More instances
2 parents 62c564a + 010efd6 commit 552284e

14 files changed

Lines changed: 744 additions & 79 deletions

File tree

‎build.sbt‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,8 @@ lazy val root = project
3737
avocado.projectRefs
3838
++ catsEffect3.projectRefs
3939
++ zio2.projectRefs
40+
++ zio1.projectRefs
41+
++ catsEffect2.projectRefs
4042
)*)
4143

4244
lazy val avocado = projectMatrix
@@ -59,6 +61,18 @@ lazy val catsEffect3 = projectMatrix
5961
.dependsOn(avocado)
6062
.jvmPlatform(scalaVersions = List(scala3))
6163

64+
lazy val catsEffect2 = projectMatrix
65+
.in(file("cats-effect-2"))
66+
.settings(commonSettings)
67+
.settings(
68+
name := "avocADO-cats-effect-2",
69+
libraryDependencies ++= Seq(
70+
"org.typelevel" %% "cats-effect" % "2.5.5"
71+
)
72+
)
73+
.dependsOn(avocado)
74+
.jvmPlatform(scalaVersions = List(scala3))
75+
6276
lazy val zio2 = projectMatrix
6377
.in(file("zio-2"))
6478
.settings(commonSettings)
@@ -70,3 +84,15 @@ lazy val zio2 = projectMatrix
7084
)
7185
.dependsOn(avocado)
7286
.jvmPlatform(scalaVersions = List(scala3))
87+
88+
lazy val zio1 = projectMatrix
89+
.in(file("zio-1"))
90+
.settings(commonSettings)
91+
.settings(
92+
name := "avocADO-zio-1",
93+
libraryDependencies ++= Seq(
94+
"dev.zio" %% "zio" % "1.0.17"
95+
)
96+
)
97+
.dependsOn(avocado)
98+
.jvmPlatform(scalaVersions = List(scala3))

‎cats-effect-2/src/main/scala/catseffect2.scala‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
package avocado.instances
2+
3+
import avocado.AvocADO
4+
import cats.Monad
5+
import cats.Parallel
6+
7+
object catseffect2 {
8+
given [F[_]: Monad: Parallel] : AvocADO[F] = new AvocADO[F] {
9+
def pure[A](a: A): F[A] = Monad[F].pure(a)
10+
def map[A, B](fa: F[A], f: A => B): F[B] = Monad[F].map(fa)(f)
11+
def zip[A, B](fa: F[A], fb: F[B]): F[(A, B)] = Parallel.parAp[F, B, (A, B)](Monad[F].map(fa)(a => (b: B) => a -> b))(fb)
12+
def flatMap[A, B](fa: F[A], f: A => F[B]): F[B] = Monad[F].flatMap(fa)(f)
13+
}
14+
}

‎cats-effect-2/src/test/scala/BaseCatsEffect2Test.scala‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
package avocado.tests
2+
3+
import cats.effect.IO
4+
import cats.effect.Timer
5+
import cats.effect.ContextShift
6+
import scala.concurrent.ExecutionContext
7+
8+
abstract class BaseCatsEffect2Test extends munit.FunSuite {
9+
10+
def testWithTimeLimit[A](name: String, maxMillis: Long)(body: IO[A])(expected: A): Unit = {
11+
test(name) {
12+
val start = System.currentTimeMillis()
13+
val res = body.unsafeRunSync()
14+
val end = System.currentTimeMillis()
15+
assertEquals(res, expected)
16+
assert(end - start < maxMillis)
17+
}
18+
}
19+
20+
given Timer[IO] = IO.timer(ExecutionContext.global)
21+
given ContextShift[IO] = IO.contextShift(ExecutionContext.global)
22+
23+
}

‎cats-effect-2/src/test/scala/CatsEffect2TCTests.scala‎

Lines changed: 201 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,201 @@
1+
package avocado.tests
2+
3+
import avocado.*
4+
import avocado.instances.catseffect2.given
5+
6+
import scala.concurrent.duration.*
7+
import cats.Monad
8+
import cats.syntax.all.*
9+
import cats.effect.IO
10+
import cats.effect.IO.given
11+
12+
class CatsEffect2TCTests extends BaseCatsEffect2Test {
13+
14+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 1", 900) {
15+
val wait = IO.sleep(500.millis)
16+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
17+
for {
18+
a <- Monad[F].pure(1)
19+
} yield a
20+
}
21+
run[IO](wait)
22+
}(1)
23+
24+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 2", 900) {
25+
val wait = IO.sleep(500.millis)
26+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
27+
for {
28+
a <- wait.map(_ => 1)
29+
b <- wait.map(_ => 2)
30+
} yield a + b
31+
}
32+
run[IO](wait)
33+
}(3)
34+
35+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 3", 1400) {
36+
val wait = IO.sleep(500.millis)
37+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
38+
for {
39+
a <- wait.map(_ => 1)
40+
b <- wait.map(_ => 2)
41+
c <- Monad[F].pure(a + b)
42+
d <- wait.map(_ => 4)
43+
} yield c + d
44+
}
45+
run[IO](wait)
46+
}(7)
47+
48+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 4", 1400) {
49+
val wait = IO.sleep(500.millis)
50+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
51+
for {
52+
a <- wait.map(_ => 1)
53+
b <- wait.map(_ => 2)
54+
c <- Monad[F].pure(a + b)
55+
d <- wait.map(_ => 4)
56+
e <- wait.map(Function.const(5))
57+
} yield c + d
58+
}
59+
run[IO](wait)
60+
}(7)
61+
62+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 5", 1400) {
63+
val wait = IO.sleep(500.millis)
64+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
65+
for {
66+
a <- wait.map(_ => 1)
67+
b <- wait.map(_ => 2)
68+
c <- Monad[F].pure(a + b)
69+
d <- wait.map(_ => 4)
70+
e <- wait
71+
} yield c + d
72+
}
73+
run[IO](wait)
74+
}(7)
75+
76+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 6", 1400) {
77+
val wait = IO.sleep(500.millis)
78+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
79+
for {
80+
a <- wait.map(_ => 1)
81+
b <- wait.map(_ => 2)
82+
c <- Monad[F].pure(a + b)
83+
d <- wait.map(_ => 4)
84+
e <- wait
85+
f <- wait
86+
g <- wait.map(Function.const(7))
87+
} yield c + d + g
88+
}
89+
run[IO](wait)
90+
}(14)
91+
92+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 7", 900) {
93+
val wait = IO.sleep(500.millis)
94+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
95+
for {
96+
a <- wait.map(_ => 1)
97+
b <- wait.map(_ => 2)
98+
_ <- wait
99+
} yield a + b
100+
}
101+
run[IO](wait)
102+
}(3)
103+
104+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 8", 900) {
105+
val wait = IO.sleep(500.millis)
106+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
107+
for {
108+
a <- wait.map(_ => 1)
109+
b <- wait.map(_ => 2)
110+
_ <- wait
111+
c <- wait.map(_ => 3)
112+
} yield a + b
113+
}
114+
run[IO](wait)
115+
}(3)
116+
117+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 9", 900) {
118+
val wait = IO.sleep(500.millis)
119+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
120+
for {
121+
_ <- wait
122+
a <- wait.map(_ => 1)
123+
b <- wait.map(_ => 2)
124+
_ <- wait
125+
c <- wait.map(_ => 3)
126+
} yield a + b
127+
}
128+
run[IO](wait)
129+
}(3)
130+
131+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 10", 1400) {
132+
val wait = IO.sleep(500.millis)
133+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
134+
for {
135+
a <- wait.map(_ => 1)
136+
_ <- wait.map(_ => a)
137+
b <- wait.map(_ => 2)
138+
c <- wait.map(_ => 3)
139+
} yield a + b
140+
}
141+
run[IO](wait)
142+
}(3)
143+
144+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 11", 900) {
145+
val wait = IO.sleep(500.millis)
146+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
147+
for {
148+
a <- wait.map(_ => 1)
149+
b <- wait.map(_ => {
150+
val a = 2
151+
a
152+
})
153+
} yield a + b
154+
}
155+
run[IO](wait)
156+
}(3)
157+
158+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 12", 900) {
159+
val wait = IO.sleep(500.millis)
160+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
161+
for {
162+
a <- wait.map(_ => 1)
163+
b <- wait.map(_ => {
164+
val a = 2
165+
a
166+
})
167+
c <- wait.map { a =>
168+
def b(): Int = 3
169+
b()
170+
}
171+
} yield a + b + c
172+
}
173+
run[IO](wait)
174+
}(6)
175+
176+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 13", 900) {
177+
val wait = IO.sleep(500.millis)
178+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
179+
for {
180+
a <- wait.map(_ => 1)
181+
b = 2
182+
c <- wait.map(_ => 3)
183+
} yield a + b + c
184+
}
185+
run[IO](wait)
186+
}(6)
187+
188+
testWithTimeLimit("cats effect 2 comprehension with typeclasses 14", 900) {
189+
val wait = IO.sleep(500.millis)
190+
def run[F[_]: Monad: AvocADO](wait: F[Unit]): F[Int] = ado {
191+
for {
192+
a <- wait.map(_ => 1)
193+
b = 2
194+
c <- wait.map(_ => 3)
195+
d = 4
196+
} yield a + b + c + d
197+
}
198+
run[IO](wait)
199+
}(10)
200+
201+
}

0 commit comments

Comments
 (0)