Build Logs

1##################################

2Clonning https://github.com/monix/monix-bio.git into /build/repo using revision v1.2.0

3##################################

4Note: switching to '471cbe3ecf13687c2c57b1e64b02818684ac2165'.

6You are in 'detached HEAD' state. You can look around, make experimental

7changes and commit them, and you can discard any commits you make in this

8state without impacting any branches by switching back to a branch.

10If you want to create a new branch to retain commits you create, you may

11do so (now or later) by using -c with the switch command. Example:

13 git switch -c <new-branch-name>

15Or undo this operation with:

17 git switch -

19Turn off this advice by setting config variable advice.detachedHead to false

21----

22Preparing build for 3.8.0-RC6

23Scala binary version found: 3.8

24Implicitly using source version 3.8

25Scala binary version found: 3.8

26Implicitly using source version 3.8

27Would try to apply common scalacOption (best-effort, sbt/mill only):

28Append: ,REQUIRE:-source:3.8

29Remove: ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

30----

31Starting build for 3.8.0-RC6

32Execute tests: true

33sbt project found:

34Sbt version 1.5.2 is not supported, minimal supported version is 1.11.5

35Enforcing usage of sbt in version 1.11.5

36No prepare script found for project monix/monix-bio

37##################################

38Scala version: 3.8.0-RC6

39Targets: io.monix%monix-bio

40Project projectConfig: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}

41##################################

42Using extra scalacOptions: ,REQUIRE:-source:3.8

43Filtering out scalacOptions: ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

44[sbt_options] declare -a sbt_options=()

45[process_args] java_version = '17'

46[copyRt] java9_rt = '/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_17_0_8/rt.jar'

47# Executing command line:

48java

49-Dfile.encoding=UTF-8

50-Dcommunitybuild.scala=3.8.0-RC6

51-Dcommunitybuild.project.dependencies.add=

52-Xmx7G

53-Xms4G

54-Xss8M

55-Dsbt.script=/root/.sdkman/candidates/sbt/current/bin/sbt

56-Dscala.ext.dirs=/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_17_0_8

57-jar

58/root/.sdkman/candidates/sbt/1.11.5/bin/sbt-launch.jar

59"setCrossScalaVersions 3.8.0-RC6"

60"++3.8.0-RC6 -v"

61"mapScalacOptions ",REQUIRE:-source:3.8,-Wconf:msg=can be rewritten automatically under:s" ",-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e""

62"set every credentials := Nil"

63"excludeLibraryDependency com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}"

64"removeScalacOptionsStartingWith -P:wartremover"

66moduleMappings

67"runBuild 3.8.0-RC6 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}""" io.monix%monix-bio"

69[info] welcome to sbt 1.11.5 (Eclipse Adoptium Java 17.0.8)

70[info] loading settings for project repo-build from akka.sbt, plugins.sbt...

71[info] loading project definition from /build/repo/project

72[info] compiling 3 Scala sources to /build/repo/project/target/scala-2.12/sbt-1.0/classes ...

73[info] Non-compiled module 'compiler-bridge_2.12' for Scala 2.12.20. Compiling...

74[info] Compilation completed in 9.398s.

75[info] done compiling

77 unmanagedSourceDirectories in FullTracingTest += {

78 ^

80 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,

81 ^

83 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,

84 ^

86 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,

87 ^

89 fork in Test := true,

90 ^

92 fork in FullTracingTest := true,

93 ^

95 javaOptions in Test ++= Seq(

96 ^

98 javaOptions in FullTracingTest ++= Seq(

99 ^

101 unidocProjectFilter in (ScalaUnidoc, unidoc) := inProjects(coreJVM),

102 ^

104 target in (ScalaUnidoc, unidoc) := (baseDirectory in LocalRootProject).value / "website" / "static" / "api",

105 ^

107 target in (ScalaUnidoc, unidoc) := (baseDirectory in LocalRootProject).value / "website" / "static" / "api",

108 ^

110 cleanFiles += (target in (ScalaUnidoc, unidoc)).value,

111 ^

113 .dependsOn(unidoc in Compile)

114 ^

116 .dependsOn(updateSiteVariables in ThisBuild)

117 ^

119 .dependsOn(unidoc in Compile)

120 ^

122 .dependsOn(updateSiteVariables in ThisBuild)

123 ^

125 scalacOptions in (ScalaUnidoc, unidoc) ++= Seq(

126 ^

128 "-sourcepath", baseDirectory.in(LocalRootProject).value.getAbsolutePath,

129 ^

131 sources in (Compile, doc) ~= (_ filterNot { file =>

132 ^

134 publishArtifact in (Compile, packageDoc) := false,

135 ^

137 publishArtifact in (Compile, packageSrc) := false,

138 ^

140 publishArtifact in (Compile, packageBin) := false

141 ^

143 scalacOptions in (Compile, doc) ~= (_ filterNot (_ == "-Xfatal-warnings")),

144 ^

146 val cp: Seq[Attributed[File]] = (fullClasspath in Compile).value

147 ^

149 scalacOptions in ThisBuild ++= Seq(

150 ^

152 resolvers += Resolver.sonatypeCentralSnapshots

154 Resolver.sonatypeRepo("releases")

155 ^

157 publishArtifact in Test := false,

158 ^

160 unmanagedSourceDirectories in Compile += {

161 ^

163 unmanagedSourceDirectories in Test += {

164 ^

166 val l = (baseDirectory in LocalRootProject).value.toURI.toString

167 ^

169 skip in publish := true,

170 ^

172updateSiteVariables in ThisBuild := {

173 ^

175 val minorVersions = (crossScalaVersions in coreJVM).value.map(minorVersion)

176 ^

178 "coreModuleName" -> (moduleName in coreJVM).value,

179 ^

181 "organization" -> (organization in LocalRootProject).value,

182 ^

184 (baseDirectory in LocalRootProject).value / "website" / "variables.js"

185 ^

187mimaFailOnNoPrevious in ThisBuild := false

188 ^

190git.baseVersion := (version in ThisBuild).value

191 ^

192[info] loading settings for project monix-bio from build.sbt...

193[info] set current project to monix-bio (in build file:/build/repo/)

194Execute setCrossScalaVersions: 3.8.0-RC6

195OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC6 in benchmarks/crossScalaVersions

196OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC6 in tracingTests/crossScalaVersions

197OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC6 in coreJVM/crossScalaVersions

198OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC6 in coreJS/crossScalaVersions

199OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC6 in monix-bio/crossScalaVersions

200[info] set current project to monix-bio (in build file:/build/repo/)

201[info] Setting Scala version to 3.8.0-RC6 on 5 projects.

202[info] Switching Scala version on:

203[info] benchmarks (2.12.13, 2.13.5, 3.8.0-RC6)

204[info] tracingTests (2.12.13, 2.13.5, 3.8.0-RC6)

205[info] coreJS (2.12.13, 2.13.5, 3.8.0-RC6)

206[info] coreJVM (2.12.13, 2.13.5, 3.8.0-RC6)

207[info] * monix-bio (2.12.13, 2.13.5, 3.8.0-RC6)

208[info] Excluding projects:

209[info] docs (2.13.5)

210[info] Reapplying settings...

211[info] set current project to monix-bio (in build file:/build/repo/)

212Execute mapScalacOptions: ,REQUIRE:-source:3.8,-Wconf:msg=can be rewritten automatically under:s ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

213[info] Reapplying settings...

214[info] set current project to monix-bio (in build file:/build/repo/)

215[info] Defining Global / credentials, benchmarks / credentials and 4 others.

216[info] The new values will be used by Global / pgpSelectPassphrase, Global / pgpSigningKey and 29 others.

217[info] Run `last` for details.

218[info] Reapplying settings...

219[info] set current project to monix-bio (in build file:/build/repo/)

220Execute excludeLibraryDependency: com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}

221[info] Reapplying settings...

222OpenCB::Failed to reapply settings in excludeLibraryDependency: Reference to undefined setting:

224 Global / allExcludeDependencies from Global / allExcludeDependencies (CommunityBuildPlugin.scala:331)

225 Did you mean tracingTests / allExcludeDependencies ?

226 , retry without global scopes

227[info] Reapplying settings...

228[info] set current project to monix-bio (in build file:/build/repo/)

229Execute removeScalacOptionsStartingWith: -P:wartremover

230[info] Reapplying settings...

231[info] set current project to monix-bio (in build file:/build/repo/)

232[success] Total time: 0 s, completed Jan 8, 2026, 1:43:36 AM

233Build config: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}

234Parsed config: Success(ProjectBuildConfig(ProjectsConfig(List(),Map()),Full,List()))

235Starting build...

236Projects: Set(coreJVM)

237Starting build for ProjectRef(file:/build/repo/,coreJVM) (monix-bio)... [0/1]

238OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.8` in Scala 2.12.20 module Global

239OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.8` in Scala 2.12.20 module Scope(Select(BuildRef(file:/build/repo/)), Zero, Zero, Zero)

240OpenCB::Filter out '-deprecation', matches setting pattern '^-?-deprecation'

241OpenCB::Filter out '-feature', matches setting pattern '^-?-feature'

242Compile scalacOptions: -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -unchecked, -language:higherKinds, -language:implicitConversions, -language:experimental.macros, -Ykind-projector, -Wconf:msg=can be rewritten automatically under:s, -source:3.8

243[info] compiling 69 Scala sources and 1 Java source to /build/repo/core/jvm/target/scala-3.8.0-RC6/classes ...

246[info] done compiling

247[info] compiling 80 Scala sources to /build/repo/core/jvm/target/scala-3.8.0-RC6/test-classes ...

250[info] done compiling

251[info] monix.bio.TaskOptionsSuite

252[info] - change options with future

253[info] - change options with callback

254[info] monix.bio.TaskCallbackSafetySuite

255[info] - IO.async's callback can be called multiple times

256[info] - IO.async0's callback can be called multiple times

257[info] - IO.asyncF's callback can be called multiple times

258[info] - IO.cancelable's callback can be called multiple times

259[info] - IO.cancelable0's callback can be called multiple times

260[info] - IO.async's register throwing is signaled as error

261[info] - IO.async0's register throwing is signaled as error

262[info] - IO.asyncF's register throwing is signaled as error (1)

263[info] - IO.asyncF's register throwing is signaled as error (2)

264[info] - IO.cancelable's register throwing is signaled as error

265[info] - IO.cancelable0's register throwing is signaled as error

266[info] - IO.async's register throwing, after result, is reported

267[info] - IO.async0's register throwing, after result, is reported

268[info] - IO.asyncF's register throwing, after result, is reported (1)

269[info] - IO.asyncF's register throwing, after result, is reported (2)

270[info] - IO.cancelable's register throwing, after result, is reported

271[info] - IO.cancelable0's register throwing, after result, is reported

272[info] monix.bio.IOLocalJVMSuite

273[info] - locals get transported with executeOn and shift

274[info] - locals get transported with executeWithModel

275[info] - locals get transported with executeWithOptions

276[info] - IOLocal.isolate can be nested with executeWithOptions

277[info] - local.write.executeOn(forceAsync = false) works

278[info] - local.write.executeOn(forceAsync = true) works

279[info] - local state is encapsulated by Task run loop with TracingScheduler

280[info] - local state is encapsulated by Task run loop without TracingScheduler

281[info] - local state is encapsulated by Task run loop on single thread

282[info] - IOLocal.isolate should properly isolate during async boundaries

283[info] - IOLocal.isolate should properly isolate during async boundaries on error

284[info] - IOLocal.isolate should properly isolate during async boundaries on cancelation

285[info] - IOLocal.isolate should isolate contexts from Future

286[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation

287[info] - Task.eval.runToFuture isolates but preserves context for Future continuation

288[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation on a single thread

289[info] - Task.eval.runToFuture continuations keep isolated context in longer continuations

290[info] - Task.eval.runToFuture can isolate future continuations

291[info] - Task.eval.runToFuture can isolate future continuations on failure

292[info] - Task.runToFuture resulting future can be reused

293[info] - Task.eval.runToFuture is isolated from outside changes

294[info] monix.bio.TaskBlockingSuite

295[info] - blocking on future should work

296[info] - blocking on async

297[info] - blocking on async.flatMap

298[info] - blocking with Termination result

299[info] - IO.eval(throw ex).attempt.runSyncUnsafe

300[info] - IO.evalTotal(throw ex).onErrorHandle.runSyncUnsafe

301[info] - IO.suspend(throw ex).attempt.runSyncUnsafe

302[info] - IO.suspendTotal(throw ex).onErrorHandle.runSyncUnsafe

303[info] - blocking on memoize

305[info] - IO.attempt.runSyncUnsafe works

306[info] monix.bio.TaskExecuteWithModelSuite

307[info] - executeWithModel works

308[info] - local.write.executeWithModel(AlwaysAsyncExecution) works

309[info] - local.write.executeWithModel(SynchronousExecution) works

310[info] - executeWithModel is stack safe in flatMap loops

311[info] monix.bio.TaskTimedSuite

312[info] - measure tasks with no errors

313[info] - not measure tasks with typed errors

314[info] - not measure tasks with terminal errors

315[info] - measure tasks with typed errors followed by `.attempt`

316[info] - not measure tasks with terminal errors followed by `.attempt`

317[info] - stack safety

318[info] monix.bio.TaskEvalOnceSuite

319[info] - IO.evalOnce should protect against user code errors

320[info] - IO.evalOnce.flatMap should be equivalent with Task.evalOnce

321[info] - IO.evalOnce.flatMap should protect against user code

322[info] - IO.evalOnce.map should work

323[info] - IO.evalOnce.flatMap should be tail recursive

324[info] - IO.EvalOnce.runAsync override

325[info] - IO.evalOnce.materialize should work for success

326[info] - IO.evalOnce.materialize should work for failure

327[info] monix.bio.TaskExecuteWithOptionsSuite

328[info] - executeWithOptions works

329[info] - local.write.executeWithOptions

330[info] - executeWithOptions is stack safe in flatMap loops

331[info] monix.bio.TaskLikeConversionsSuite

332[info] - IO.from(task.to[IO]) <-> task

333[info] - IO.from converts successful Future

334[info] - IO.from converts failed Future

335[info] - IO.from converts successful sync IO

336[info] - IO.from converts successful async IO

337[info] - IO.from converts failed sync CIO

338[info] - IO.from converts failed async IO

339[info] - IO.from preserves cancellability of an IO

340[info] - IO.from converts successful Eval

341[info] - IO.from converts failed Eval

342[info] - IO.from preserves Eval laziness

343[info] - IO.from converts successful SyncIO

344[info] - IO.from converts failed SyncIO

345[info] - IO.from converts successful Try

346[info] - IO.from converts failed Try

347[info] - IO.from converts right Either

348[info] - IO.from converts left Either

349[info] - IO.from converts successful custom Effect

350[info] - IO.from converts failed custom Effect

351[info] - IO.from converts successful custom ConcurrentEffect

352[info] - IO.from converts failed custom ConcurrentEffect

353[info] - IO.from converts Function0

354[info] - IO.from converts CancelablePromise

355[info] monix.bio.TaskCallbackSuite

356[info] - onValue should invoke onSuccess

357[info] - apply Success(Right(value)) should invoke onSuccess

358[info] - apply Success(Left(value)) should invoke onError

359[info] - apply Failure(ex) should invoke onTermination

360[info] - contramap should pipe onError

361[info] - contramap should invoke function before invoking callback

362[info] - BiCallback.fromPromise (success)

363[info] - BiCallback.fromPromise (failure)

364[info] - BiCallback.fromPromise (terminal failure)

365[info] - BiCallback.fromPromise(Cause) (terminal failure)

366[info] - BiCallback.empty reports errors

367[info] - BiCallback.empty reports terminal errors

368[info] - BiCallback.safe protects against errors in onSuccess

369[info] - BiCallback.safe protects against errors in onError

370[info] - BiCallback.safe protects against errors in onTermination

371[info] - callback(Right(a))

372[info] - callback(Left(e))

373[info] - callback(Left(ex))

374[info] - fromAttempt success

375[info] - fromAttempt error

376[info] - fromAttempt termination

377[info] monix.bio.TaskSuspendSuite

378[info] - IO.suspend should suspend evaluation

379[info] - IO.suspend should protect against user code errors

380[info] - IO.suspendTotal should protect against unexpected errors

381[info] monix.bio.TaskParTraverseSuite

382[info] - IO.parTraverse should execute in parallel for async tasks

383[info] - IO.parTraverse should onError if one of the tasks terminates in error

384[info] - IO.parTraverse should onTerminate if one of the tasks terminates in unexpected error

385[info] - IO.parTraverse should be canceled

386[info] - IO.parTraverse should be stack safe for synchronous tasks

387[info] - IO.parTraverse runAsync multiple times

389[info] monix.bio.TaskConversionsKSuite

390[info] - Task.liftTo[CIO]

391[info] - Task.liftToAsync[IO]

392[info] - Task.liftToConcurrent[IO]

393[info] - Task.liftFrom[IO]

394[info] - Task.liftFromEffect[IO]

395[info] - Task.liftFromConcurrentEffect[IO]

396[info] monix.bio.IOLocalSuite

397[info] - IOLocal.apply

398[info] - IOLocal.wrap

399[info] - IOLocal!.bind

400[info] - IOLocal!.bindL

401[info] - IOLocal!.bindClear

402[info] - IOLocal canceled

403[info] - IOLocal!.local

404[info] - TaskLocals get restored in IO.create on error

405[info] - TaskLocals get restored in IO.create on termination

406[info] - IOLocal should work with bracket

407[info] - IOLocal.isolate should prevent context changes

408[info] - IOLocal interop with future via deferFutureAction

409[info] - IOLocal.bind scoping works

410[info] - IOLocal.bind actually isolates reads

411[info] - IOLocal.isolate with ConcurrentChannel

412[info] monix.bio.TaskCreateSuite

413[info] - can use Unit as return type

414[info] - can use Cancelable.empty as return type

415[info] - returning Unit yields non-cancelable tasks

416[info] - can use Cancelable as return type

417[info] - returning Cancelable yields a cancelable task

418[info] - can use CIO[Unit] as return type

419[info] - returning CIO[Unit] yields a cancelable task

420[info] - can use IO[E, Unit] as return type

421[info] - returning IO[E, Unit] yields a cancelable task

422[info] - throwing error when returning Unit

423[info] - throwing error when returning Cancelable

424[info] monix.bio.IOMapNSuite

425[info] - IO#map2 should yield value successfully

426[info] - IO#map2 should propagate error when one argument failed

427[info] - IO#map2 should protect against user code

428[info] - IO#map2 should run effects in strict sequence

429[info] - IO#map3 should yield value successfully

430[info] - IO#map3 should propagate error when one argument failed

431[info] - IO#map3 should protect against user code

432[info] - IO#map3 should run effects in strict sequence

433[info] - IO#map4 should yield value successfully

434[info] - IO#map4 should propagate error when one argument failed

435[info] - IO#map4 should protect against user code

436[info] - IO#map4 should run effects in strict sequence

437[info] - IO#map5 should yield value successfully

438[info] - IO#map5 should propagate error when one argument failed

439[info] - IO#map5 should protect against user code

440[info] - IO#map5 should run effects in strict sequence

441[info] - IO#map6 should yield value successfully

442[info] - IO#map6 should propagate error when one argument failed

443[info] - IO#map6 should protect against user code

444[info] - IO#map6 should run effects in strict sequence

445[info] monix.bio.TaskMiscSuite

446[info] - IO.attempt should succeed

447[info] - IO.raiseError.attempt should expose error

448[info] - IO.mapError should map error

449[info] - IO.terminate.attempt should not expose error

450[info] - IO.tapError should not alter original successful value

451[info] - IO.tapError should not alter original error value

452[info] - IO.tapError should not alter original terminal error

453[info] - IO.failed should expose error

454[info] - IO.failed should fail for successful values

455[info] - IO.map protects against user code

456[info] - IO.forever

457[info] - IO.restartUntil should keep retrying IO until predicate succeeds

458[info] - IO.toReactivePublisher should convert tasks with no errors

459[info] - IO.toReactivePublisher should convert tasks with typed errors

460[info] - IO.toReactivePublisher should convert tasks with terminal errors

461[info] - IO.toReactivePublisher should be cancelable

462[info] - IO.toReactivePublisher should throw errors on invalid requests

463[info] - IO.pure is an alias of now

464[info] - IO.now.runAsync with Try-based callback

465[info] - Task.error.runAsync with Try-based callback

466[info] - Task.terminate.runAsync with Try-based callback

467[info] - task.executeAsync.runAsync with Try-based callback for success

468[info] - task.executeAsync.runAsync with Try-based callback for error

469[info] - task.executeAsync.runAsync with Try-based callback for terminal error

470[info] - task.executeWithOptions protects against user error

471[info] monix.bio.TaskConversionsSuite

472[info] - IO.now(value).to[CIO]

473[info] - IO.eval(thunk).to[CIO]

474[info] - IO.eval(thunk).executeAsync.to[CIO]

475[info] - IO.evalTotal(thunk).to[CIO]

476[info] - IO.evalTotal(thunk).executeAsync.to[CIO]

477[info] - IO.raiseError(dummy).to[CIO]

478[info] - IO.raiseError(dummy).executeAsync.to[CIO]

479[info] - IO.terminate(dummy).to[CIO]

480[info] - IO.terminate(dummy).executeAsync.to[CIO]

481[info] - IO.toAsync converts successful tasks

482[info] - IO.toAsync converts tasks with typed errors

483[info] - IO.toAsync converts tasks with terminal errors

484[info] - IO.toConcurrent converts successful tasks

485[info] - IO.toConcurrent converts tasks with typed errors

486[info] - IO.toConcurrent converts tasks with terminal errors

487[info] - IO.fromEffect(task)) <-> task

488[info] - IO.fromEffect(task.toAsync[Task]) <-> task

489[info] - IO.fromEffect(task.toAsync[CIO]) <-> task

490[info] - IO.fromEffect(task.toAsync[F]) <-> task

491[info] - IO.fromEffect converts `IO`

492[info] - IO.fromEffect converts valid custom effects

493[info] - IO.fromEffect doesn't convert invalid custom effects

494[info] - IO.fromEffect(task.toConcurrent[IO]) preserves cancellability

495[info] - IO.fromConcurrentEffect(task) <-> task

496[info] - IO.fromConcurrentEffect(task.toConcurrent[Task]) <-> task

497[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) <-> task

498[info] - IO.fromConcurrentEffect(task.toConcurrent[F]) <-> task

499[info] - IO.fromConcurrentEffect converts `IO`

500[info] - IO.fromConcurrentEffect converts valid custom effects

501[info] - IO.fromConcurrentEffect doesn't convert invalid custom effects

502[info] - IO.fromConcurrentEffect preserves cancellability of an `IO`

503[info] - IO.fromConcurrentEffect preserves cancellability of a custom effect

504[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) preserves cancellability

505[info] - IO.fromConcurrentEffect(task.toConcurrent[CIO]) preserves cancellability

506[info] - IO.fromReactivePublisher converts `.onNext` callbacks

507[info] - IO.fromReactivePublisher converts `.onComplete` callbacks

508[info] - IO.fromReactivePublisher converts `.onError` callbacks

509[info] - IO.fromReactivePublisher protects against user errors

510[info] - IO.fromReactivePublisher is cancelable

511[info] - IO.fromReactivePublisher <-> Task

512[info] monix.bio.TaskBracketSuite

513[info] - equivalence with onErrorHandleWith

514[info] - equivalence with flatMap + redeemWith

515[info] - equivalence with flatMap + redeemCauseWith

516[info] - use is protected against user error

517[info] - release is evaluated on success

518[info] - release is evaluated on error

519[info] - release is evaluated on terminal error

520[info] - release is evaluated on cancel

521[info] - if both use and release throw, report release error, signal use error

522[info] - bracket works with auto-cancelable run-loops

523[info] - bracket is stack safe (1)

524[info] - bracket is stack safe (2)

525[info] - bracket is stack safe (3)

526[info] - bracket is stack safe (4)

527[info] - use is not evaluated on cancel

528[info] - cancel should wait for already started finalizers on success

529[info] - cancel should wait for already started finalizers on failure

530[info] - cancel should wait for already started use finalizers

531[info] - second cancel should wait for use finalizers

532[info] - second cancel during acquire should wait for it and finalizers to complete

533[info] - second cancel during acquire should wait for it and finalizers to complete (non-terminating)

534[info] - Multiple cancel should not hang

535[info] - bracket can be canceled while failing to acquire

536[info] - bracket can be canceled while terminating

537[info] monix.bio.TaskAsyncBoundarySuite

538[info] - IO.asyncBoundary should work

539[info] - IO.asyncBoundary(other) should work

540[info] - IO.asyncBoundary should preserve locals

541[info] - IO.asyncBoundary(scheduler) should preserve locals

542[info] - IO.asyncBoundary is stack safe in flatMap loops, test 1

543[info] - IO.asyncBoundary is stack safe in flatMap loops, test 2

544[info] monix.bio.IOLikeDoctest

545[info] - IOLike.scala:29: IOLike

546[info] monix.bio.IODoOnFinishSuite

547[info] - IO#doOnFinish should work on successful task

548[info] - IO#doOnFinish should work on task with raised error

549[info] - IO#doOnFinish should work on terminated task

550[info] - IO#doOnFinish should not trigger any finishing action when IO is cancelled

551[info] monix.bio.TaskMapBothSuite

552[info] - if both tasks are synchronous, then mapBoth forks

553[info] - sum two async tasks

554[info] - sum two synchronous tasks

555[info] - should be stack-safe for synchronous tasks

556[info] - should be stack-safe for asynchronous tasks

557[info] - should have a stack safe cancelable

558[info] - sum random synchronous tasks

559[info] - sum random asynchronous tasks

560[info] - both task can fail with error

561[info] - both task can fail with terminal error

562[info] monix.bio.TaskEvalAlwaysSuite

563[info] - IO.eval should work synchronously

564[info] - IO.eval should protect against user code errors

565[info] - IO.eval is equivalent with IO.evalOnce on first run

566[info] - IO.eval.flatMap should be equivalent with IO.eval

567[info] - IO.eval.flatMap should protect against user code

568[info] - IO.eval.flatMap should be tail recursive

569[info] - IO.eval should not be cancelable

570[info] - IO.eval.coeval

571[info] - IO.eval.flatMap should protect against user code errors

572[info] - IO.delay is an alias for IO.eval

573[info] - IO.evalTotal should protect against unexpected errors

574[info] monix.bio.TaskErrorSuite

575[info] - IO.attempt should expose typed error

576[info] - IO.attempt should not expose unexpected error

577[info] - IO.attempt should work for successful values

578[info] - IO.rethrow should turn Left to typed error

579[info] - IO.rethrow should turn Right to success value

580[info] - IO.failed should expose typed error

581[info] - IO.failed should fail for unexpected error

582[info] - IO.failed should fail for successful values

583[info] - IO#onErrorRecover should mirror source on success

584[info] - IO#onErrorRecover should recover typed error

585[info] - IO#onErrorRecover should not recover unexpected error

586[info] - IO#onErrorRecover should protect against user code

587[info] - IO#onErrorHandle should mirror source on success

588[info] - IO#onErrorHandle should recover typed error

589[info] - IO#onErrorHandle should not recover unexpected error

590[info] - IO#onErrorHandle should protect against user code

591[info] - IO.onErrorFallbackTo should mirror source onSuccess

592[info] - IO.onErrorFallbackTo should fallback to backup onError

593[info] - IO.onErrorFallbackTo should not fallback to backup onTermination

594[info] - IO.onErrorFallbackTo should protect against user code

595[info] - IO.onErrorFallbackTo should be cancelable if the ExecutionModel allows it

596[info] - IO.onErrorRestart should mirror the source onSuccess

597[info] - IO.onErrorRestart should retry onError

598[info] - IO.onErrorRestart should emit onError after max retries

599[info] - IO.onErrorRestart should be cancelable if ExecutionModel permits

600[info] - IO.onErrorRestart should not restart on terminate error

601[info] - IO.onErrorRestartIf should mirror the source onSuccess

602[info] - IO.onErrorRestartIf should retry onError

603[info] - IO.onErrorRestartIf should emit onError

604[info] - IO.onErrorRestartIf should be cancelable if ExecutionModel permits

605[info] - IO.onErrorRestartIf should not restart on terminate error

606[info] - IO.onErrorRestartIf should restart on typed error

607[info] - IO#onErrorRecoverWith should mirror source on success

608[info] - IO#onErrorRecoverWith should recover

613[info] - IO#onErrorRecoverWith should protect against user code

614[info] - IO#onErrorRecoverWith has a cancelable fallback

615[info] - IO#onErrorRecover should emit error if not matches

616[info] - IO#onErrorRecoverWith should emit error if not matches

617[info] - IO.eval.flatMap.redeemCauseWith should work

618[info] - IO.evalAsync.flatMap.redeemCauseWith should work

619[info] - IO.now.onErrorRecoverWith should be stack safe

620[info] - onErrorRecoverWith should be stack safe for loop with executeAsync boundaries

621[info] - Task.onErrorRestartLoop works for success

622[info] - Task.onErrorRestartLoop can throw different error

623[info] - Task.onErrorRestartLoop can rethrow

624[info] monix.bio.TaskDeferActionSuite

625[info] - IO.deferAction works

626[info] - IO.deferAction works for failed tasks

627[info] - IO.deferAction protects against user error

628[info] - IO.deferAction should properly cast errors

629[info] - IO.deferAction is stack safe

630[info] - IO.deferAction(local.write) works

631[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite

632[info] - CoflatMap[Task].coflatMap.coflatMap associativity

633[info] - CoflatMap[Task].coflatMap.coflatMap identity

634[info] - CoflatMap[Task].coflatMap.coflatten coherence

635[info] - CoflatMap[Task].coflatMap.coflatten throughMap

636[info] - CoflatMap[Task].coflatMap.covariant composition

637[info] - CoflatMap[Task].coflatMap.covariant identity

638[info] - CoflatMap[Task].coflatMap.invariant composition

639[info] - CoflatMap[Task].coflatMap.invariant identity

640[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

641[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

642[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

643[info] - Concurrent[Task].concurrent.ap consistent with product + map

644[info] - Concurrent[Task].concurrent.applicative homomorphism

645[info] - Concurrent[Task].concurrent.applicative identity

646[info] - Concurrent[Task].concurrent.applicative interchange

647[info] - Concurrent[Task].concurrent.applicative map

648[info] - Concurrent[Task].concurrent.applicative unit

649[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

650[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

651[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

652[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

653[info] - Concurrent[Task].concurrent.applicativeError handle

654[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

655[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

656[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

657[info] - Concurrent[Task].concurrent.applicativeError handleError pure

658[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

659[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

660[info] - Concurrent[Task].concurrent.applicativeError handleWith

661[info] - Concurrent[Task].concurrent.applicativeError onError pure

662[info] - Concurrent[Task].concurrent.applicativeError onError raise

663[info] - Concurrent[Task].concurrent.applicativeError pure attempt

664[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

665[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

666[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

667[info] - Concurrent[Task].concurrent.apply composition

668[info] - Concurrent[Task].concurrent.async can be derived from asyncF

669[info] - Concurrent[Task].concurrent.async cancelable coherence

670[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

671[info] - Concurrent[Task].concurrent.async left is raiseError

672[info] - Concurrent[Task].concurrent.async right is pure

673[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

674[info] - Concurrent[Task].concurrent.bind suspends evaluation

675[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

676[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

677[info] - Concurrent[Task].concurrent.bracket release is called on cancel

678[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

679[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

680[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

681[info] - Concurrent[Task].concurrent.covariant composition

682[info] - Concurrent[Task].concurrent.covariant identity

683[info] - Concurrent[Task].concurrent.delay constant is pure

684[info] - Concurrent[Task].concurrent.flatMap associativity

685[info] - Concurrent[Task].concurrent.flatMap consistent apply

686[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

687[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

688[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

689[info] - Concurrent[Task].concurrent.invariant composition

690[info] - Concurrent[Task].concurrent.invariant identity

691[info] - Concurrent[Task].concurrent.join is idempotent

692[info] - Concurrent[Task].concurrent.map flatMap coherence

693[info] - Concurrent[Task].concurrent.map suspends evaluation

694[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

695[info] - Concurrent[Task].concurrent.map2/product-map consistency

696[info] - Concurrent[Task].concurrent.monad left identity

697[info] - Concurrent[Task].concurrent.monad right identity

698[info] - Concurrent[Task].concurrent.monadError ensure consistency

699[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

700[info] - Concurrent[Task].concurrent.monadError left zero

701[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

702[info] - Concurrent[Task].concurrent.monadError rethrow attempt

703[info] - Concurrent[Task].concurrent.monoidal left identity

704[info] - Concurrent[Task].concurrent.monoidal right identity

705[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

706[info] - Concurrent[Task].concurrent.never is derived from async

707[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

708[info] - Concurrent[Task].concurrent.productL consistent map2

709[info] - Concurrent[Task].concurrent.productR consistent map2

710[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

711[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

712[info] - Concurrent[Task].concurrent.race cancels both

713[info] - Concurrent[Task].concurrent.race cancels loser

714[info] - Concurrent[Task].concurrent.race mirrors left winner

715[info] - Concurrent[Task].concurrent.race mirrors right winner

716[info] - Concurrent[Task].concurrent.racePair can join left

717[info] - Concurrent[Task].concurrent.racePair can join right

718[info] - Concurrent[Task].concurrent.racePair cancels both

719[info] - Concurrent[Task].concurrent.racePair cancels loser

720[info] - Concurrent[Task].concurrent.racePair mirrors left winner

721[info] - Concurrent[Task].concurrent.racePair mirrors right winner

722[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

723[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

724[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

725[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

726[info] - Concurrent[Task].concurrent.semigroupal associativity

727[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

728[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

729[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

730[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

731[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

732[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

733[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

734[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

735[info] - Concurrent[Task].concurrent.start then join is identity

736[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

737[info] - Concurrent[Task].concurrent.suspend constant is pure join

738[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

739[info] - Concurrent[Task].concurrent.tailRecM stack safety

740[info] - Concurrent[Task].concurrent.throw in delay is raiseError

741[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

742[info] - Concurrent[Task].concurrent.uncancelable mirrors source

743[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

744[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

745[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

746[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

747[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

748[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

749[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

750[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

751[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

752[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

753[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

754[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

755[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

756[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

757[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

758[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

759[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

760[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

761[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

762[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

763[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

764[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

765[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

766[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

767[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

768[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

769[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

770[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

771[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

772[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

773[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

774[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

775[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

776[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

777[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

778[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

779[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

780[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

781[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

782[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

783[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

784[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

785[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

786[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

787[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

788[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

789[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

790[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

791[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

792[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

793[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

794[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

795[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

796[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

797[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

798[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

799[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

800[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

801[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

802[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

803[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

804[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

805[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

806[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

807[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

808[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

809[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

810[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

811[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

812[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

813[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

814[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

815[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

816[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

817[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

818[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

819[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

820[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

821[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

822[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

823[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

824[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

825[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

826[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

827[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

828[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

829[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

830[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

831[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

832[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

833[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

834[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

835[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

836[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

837[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

838[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

839[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

840[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

841[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

842[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

843[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

844[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

845[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

846[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

847[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

848[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

849[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

850[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

851[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

852[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

853[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

854[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

855[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

856[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

857[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

858[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

859[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

860[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

861[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

862[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

863[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

864[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

865[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

866[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

867[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

868[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

869[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

870[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

871[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

872[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

873[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

874[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

875[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

876[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

877[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

878[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

879[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

880[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

881[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

882[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

883[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

884[info] - Parallel[IO, IO.Par].parallel.parallel round trip

885[info] - Parallel[IO, IO.Par].parallel.sequential round trip

886[info] - Monoid[IO[String, Int]].monoid.associative

887[info] - Monoid[IO[String, Int]].monoid.collect0

888[info] - Monoid[IO[String, Int]].monoid.combine all

889[info] - Monoid[IO[String, Int]].monoid.combineAllOption

890[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

891[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

892[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

893[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

894[info] - Monoid[IO[String, Int]].monoid.is id

895[info] - Monoid[IO[String, Int]].monoid.left identity

896[info] - Monoid[IO[String, Int]].monoid.repeat0

897[info] - Monoid[IO[String, Int]].monoid.repeat1

898[info] - Monoid[IO[String, Int]].monoid.repeat2

899[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

900[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

901[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

902[info] - Monoid[IO[String, Int]].monoid.reverseReverses

903[info] - Monoid[IO[String, Int]].monoid.right identity

904[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

905[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

906[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

907[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

908[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

909[info] monix.bio.TaskFlatMapSuite

910[info] - runAsync flatMap loop is not cancelable if autoCancelableRunLoops=false

911[info] - runAsync flatMap loop is cancelable if ExecutionModel permits

912[info] - runAsync(callback) flatMap loop is cancelable if ExecutionModel permits

913[info] - redeemWith derives flatMap

914[info] - redeemWith derives onErrorHandleWith

915[info] - redeem derives map . onErrorHandle

916[info] - redeem derives onErrorHandle

917[info] - redeemWith can recover

918[info] - redeem can recover

919[info] - >> is stack safe for infinite loops

920[info] - flatMapLoop enables loops

921[info] monix.bio.TaskFlipSuite

922[info] - flip successfully swaps the error and value parameters

923[info] - flipWith should successfully apply the provided function to the swapped error value

924[info] - flip should not alter original successful value

925[info] - flipWith should not alter original successful value

926[info] - F.flip.map(f) <-> F.mapError(f).flip

927[info] - F.flipWith(f) <-> F.mapError(f)

928[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite

929[info] - CoflatMap[Task].coflatMap.coflatMap associativity

930[info] - CoflatMap[Task].coflatMap.coflatMap identity

931[info] - CoflatMap[Task].coflatMap.coflatten coherence

932[info] - CoflatMap[Task].coflatMap.coflatten throughMap

933[info] - CoflatMap[Task].coflatMap.covariant composition

934[info] - CoflatMap[Task].coflatMap.covariant identity

935[info] - CoflatMap[Task].coflatMap.invariant composition

936[info] - CoflatMap[Task].coflatMap.invariant identity

937[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

938[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

939[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

940[info] - Concurrent[Task].concurrent.ap consistent with product + map

941[info] - Concurrent[Task].concurrent.applicative homomorphism

942[info] - Concurrent[Task].concurrent.applicative identity

943[info] - Concurrent[Task].concurrent.applicative interchange

944[info] - Concurrent[Task].concurrent.applicative map

945[info] - Concurrent[Task].concurrent.applicative unit

946[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

947[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

948[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

949[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

950[info] - Concurrent[Task].concurrent.applicativeError handle

951[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

952[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

953[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

954[info] - Concurrent[Task].concurrent.applicativeError handleError pure

955[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

956[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

957[info] - Concurrent[Task].concurrent.applicativeError handleWith

958[info] - Concurrent[Task].concurrent.applicativeError onError pure

959[info] - Concurrent[Task].concurrent.applicativeError onError raise

960[info] - Concurrent[Task].concurrent.applicativeError pure attempt

961[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

962[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

963[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

964[info] - Concurrent[Task].concurrent.apply composition

965[info] - Concurrent[Task].concurrent.async can be derived from asyncF

966[info] - Concurrent[Task].concurrent.async cancelable coherence

967[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

968[info] - Concurrent[Task].concurrent.async left is raiseError

969[info] - Concurrent[Task].concurrent.async right is pure

970[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

971[info] - Concurrent[Task].concurrent.bind suspends evaluation

972[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

973[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

974[info] - Concurrent[Task].concurrent.bracket release is called on cancel

975[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

976[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

977[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

978[info] - Concurrent[Task].concurrent.covariant composition

979[info] - Concurrent[Task].concurrent.covariant identity

980[info] - Concurrent[Task].concurrent.delay constant is pure

981[info] - Concurrent[Task].concurrent.flatMap associativity

982[info] - Concurrent[Task].concurrent.flatMap consistent apply

983[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

984[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

985[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

986[info] - Concurrent[Task].concurrent.invariant composition

987[info] - Concurrent[Task].concurrent.invariant identity

988[info] - Concurrent[Task].concurrent.join is idempotent

989[info] - Concurrent[Task].concurrent.map flatMap coherence

990[info] - Concurrent[Task].concurrent.map suspends evaluation

991[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

992[info] - Concurrent[Task].concurrent.map2/product-map consistency

993[info] - Concurrent[Task].concurrent.monad left identity

994[info] - Concurrent[Task].concurrent.monad right identity

995[info] - Concurrent[Task].concurrent.monadError ensure consistency

996[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

997[info] - Concurrent[Task].concurrent.monadError left zero

998[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

999[info] - Concurrent[Task].concurrent.monadError rethrow attempt

1000[info] - Concurrent[Task].concurrent.monoidal left identity

1001[info] - Concurrent[Task].concurrent.monoidal right identity

1002[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

1003[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

1004[info] - Concurrent[Task].concurrent.productL consistent map2

1005[info] - Concurrent[Task].concurrent.productR consistent map2

1006[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

1007[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

1008[info] - Concurrent[Task].concurrent.race cancels both

1009[info] - Concurrent[Task].concurrent.race cancels loser

1010[info] - Concurrent[Task].concurrent.race mirrors left winner

1011[info] - Concurrent[Task].concurrent.race mirrors right winner

1012[info] - Concurrent[Task].concurrent.racePair can join left

1013[info] - Concurrent[Task].concurrent.racePair can join right

1014[info] - Concurrent[Task].concurrent.racePair cancels both

1015[info] - Concurrent[Task].concurrent.racePair cancels loser

1016[info] - Concurrent[Task].concurrent.racePair mirrors left winner

1017[info] - Concurrent[Task].concurrent.racePair mirrors right winner

1018[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

1019[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

1020[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

1021[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

1022[info] - Concurrent[Task].concurrent.semigroupal associativity

1023[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

1024[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

1025[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

1026[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

1027[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

1028[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

1029[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

1030[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

1031[info] - Concurrent[Task].concurrent.start then join is identity

1032[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

1033[info] - Concurrent[Task].concurrent.suspend constant is pure join

1034[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

1035[info] - Concurrent[Task].concurrent.tailRecM stack safety

1036[info] - Concurrent[Task].concurrent.throw in delay is raiseError

1037[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

1038[info] - Concurrent[Task].concurrent.uncancelable mirrors source

1039[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

1040[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

1041[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

1042[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

1043[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

1044[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

1045[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

1046[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

1047[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

1048[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

1049[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

1050[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

1051[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

1052[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

1053[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

1054[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

1055[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

1056[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

1057[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

1058[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

1059[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

1060[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

1061[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

1062[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

1063[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

1064[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

1065[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

1066[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

1067[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

1068[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

1069[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

1070[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

1071[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

1072[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

1073[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

1074[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

1075[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

1076[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

1077[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

1078[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

1079[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

1080[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

1081[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1082[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

1083[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

1084[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

1085[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

1086[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

1087[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

1088[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

1089[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

1090[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

1091[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

1092[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

1093[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

1094[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

1095[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

1096[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

1097[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

1098[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

1099[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

1100[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

1101[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

1102[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

1103[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

1104[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

1105[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

1106[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

1107[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

1108[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

1109[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

1110[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

1111[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

1112[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

1113[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

1114[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

1115[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

1116[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

1117[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

1118[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

1119[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

1120[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

1121[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

1122[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

1123[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

1124[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

1125[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

1126[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

1127[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

1128[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

1129[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

1130[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

1131[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

1132[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

1133[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

1134[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

1135[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

1136[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

1137[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

1138[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

1139[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

1140[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

1141[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

1142[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

1143[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

1144[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

1145[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

1146[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

1147[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

1148[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

1149[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

1150[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

1151[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

1152[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

1153[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

1154[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

1155[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

1156[info] - Applicative[Task.Par].applicative.ap consistent with product + map

1157[info] - Applicative[Task.Par].applicative.applicative homomorphism

1158[info] - Applicative[Task.Par].applicative.applicative identity

1159[info] - Applicative[Task.Par].applicative.applicative interchange

1160[info] - Applicative[Task.Par].applicative.applicative map

1161[info] - Applicative[Task.Par].applicative.applicative unit

1162[info] - Applicative[Task.Par].applicative.apply composition

1163[info] - Applicative[Task.Par].applicative.covariant composition

1164[info] - Applicative[Task.Par].applicative.covariant identity

1165[info] - Applicative[Task.Par].applicative.invariant composition

1166[info] - Applicative[Task.Par].applicative.invariant identity

1167[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

1168[info] - Applicative[Task.Par].applicative.map2/product-map consistency

1169[info] - Applicative[Task.Par].applicative.monoidal left identity

1170[info] - Applicative[Task.Par].applicative.monoidal right identity

1171[info] - Applicative[Task.Par].applicative.productL consistent map2

1172[info] - Applicative[Task.Par].applicative.productR consistent map2

1173[info] - Applicative[Task.Par].applicative.semigroupal associativity

1174[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1175[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1176[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1177[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1178[info] - Monoid[IO[Throwable, Int]].monoid.associative

1179[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1180[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1181[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1182[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1183[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1184[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1185[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1186[info] - Monoid[IO[Throwable, Int]].monoid.is id

1187[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1188[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1189[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1190[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1191[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1192[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1193[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1194[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1195[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1196[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1197[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1198[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1199[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1200[info] monix.bio.TaskToStringSuite

1201[info] - IO.Now

1202[info] - IO.Error

1203[info] - IO.Termination

1204[info] - IO.Eval

1205[info] - IO.EvalTotal

1206[info] - IO.Async

1207[info] - IO.FlatMap

1208[info] - IO.Suspend

1209[info] - IO.SuspendTotal

1210[info] - IO.Map

1211[info] monix.bio.TaskExecutionModelSuite

1212[info] - IO.now.executeWithModel(AlwaysAsyncExecution) should work

1213[info] - IO.now.runAsync (CancelableFuture) should not be async with AlwaysAsyncExecution

1214[info] - IO.eval.executeWithModel(AlwaysAsyncExecution) should work

1215[info] - IO.eval should be async with AlwaysAsyncExecution

1216[info] - IO.now.flatMap loops should work with AlwaysAsyncExecution

1217[info] - IO.eval.flatMap loops should work with AlwaysAsyncExecution

1218[info] - IO.flatMap loops should work with AlwaysAsyncExecution

1219[info] monix.bio.IOParZipSuite

1220[info] - IO.parZip2 should work if source finishes first

1221[info] - IO.parZip2 should work if other finishes first

1222[info] - IO.parZip2 should cancel both

1223[info] - IO.parZip2 should cancel just the source

1224[info] - IO.parZip2 should cancel just the other

1225[info] - IO.parZip2 should onError from the source before other

1226[info] - IO.parZip2 handle terminal errors from the source before other

1227[info] - IO.parZip2 should onError from the other after the source

1228[info] - IO.parZip2 should handle terminal errors from the other after the source

1229[info] - IO.parZip2 should onError from the other before the source

1230[info] - IO.parZip2 works

1231[info] - IO.map2 works

1232[info] - IO#map2 should protect against user code

1233[info] - IO.map2 runs effects in strict sequence

1234[info] - IO.parMap2 works

1235[info] - IO#parMap2 should protect against user code

1236[info] - IO.parZip3 works

1237[info] - IO#map3 works

1238[info] - IO#parMap3 works

1239[info] - IO.parZip4 works

1240[info] - IO#map4 works

1241[info] - IO#parMap4 works

1242[info] - IO.parZip5 works

1243[info] - IO#map5 works

1244[info] - IO#parMap5 works

1245[info] - IO.parZip6 works

1246[info] - IO#map6 works

1247[info] - IO#parMap6 works

1248[info] monix.bio.TaskRaceSuite

1249[info] - IO.raceMany returns fastest success

1250[info] - IO.raceMany returns fastest typed error

1251[info] - IO.raceMany returns fastest terminal error

1252[info] - IO.raceMany returns success that is faster than typed error

1253[info] - IO.raceMany returns success that is faster than terminal error

1254[info] - IO.raceMany returns typed error that is faster than success

1255[info] - IO.raceMany returns typed error that is faster than fatal error

1256[info] - IO.raceMany returns fatal error that is faster than success

1257[info] - IO.raceMany returns fatal error that is faster than typed error

1258[info] - IO.raceMany should allow cancelling all tasks

1259[info] - IO.raceMany should be stack safe for sync values

1260[info] - IO.raceMany should be stack safe for async values

1261[info] - IO.raceMany has a stack safe cancelable

1262[info] - IO#timeout should timeout

1263[info] - IO#timeout should mirror the source in case of success

1264[info] - IO#timeout should mirror the source in case of error

1265[info] - IO#timeout should mirror the source in case of terminal error

1266[info] - IO#timeout should cancel both the source and the timer

1267[info] - IO#timeout with backup should timeout

1268[info] - IO#timeout with backup should timeout with error

1269[info] - IO#timeout with backup should mirror the source in case of success

1270[info] - IO#timeout with backup should mirror the source in case of error

1271[info] - IO#timeout should cancel both the source and the timer

1272[info] - IO#timeout should cancel the backup

1273[info] - IO#timeout should not return the source after timeout

1274[info] - IO#timeout should cancel the source after timeout

1275[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization

1276[info] - IO#timeoutL should evaluate as specified: lazy, with memoization

1277[info] - IO#timeoutL considers time taken to evaluate the duration task

1278[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed

1279[info] - IO.racePair(a,b) should work if a completes first

1280[info] - IO.racePair(a,b) should cancel both

1281[info] - IO.racePair(A,B) should not cancel B if A completes first

1282[info] - IO.racePair(A,B) should not cancel A if B completes first

1283[info] - IO.racePair(A,B) should end both in error if A completes first in error

1284[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error

1285[info] - IO.racePair(A,B) should end both in error if B completes first in error

1286[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error

1287[info] - IO.racePair(A,B) should work if A completes second in error

1288[info] - IO.racePair(A,B) should work if A completes second in terminal error

1289[info] - IO.racePair(A,B) should work if B completes second in error

1290[info] - IO.racePair should be stack safe, take 1

1291[info] - IO.racePair should be stack safe, take 2

1292[info] - IO.racePair has a stack safe cancelable

1293[info] - IO.race(a, b) should work if a completes first

1294[info] - IO.race(a, b) should work if b completes first

1295[info] - IO.race(a, b) should cancel both

1296[info] - IO.race(a, b) should end both in error if `a` completes first in error

1297[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error

1298[info] - IO.race(a, b) should end both in error if `b` completes first in error

1299[info] - IO.race(a, b) should end both in error if `b` completes first in error

1300[info] - IO.race(a, b) should work if `a` completes in typed error

1301[info] - IO.race(a, b) should work if `a` completes in unexpected error

1302[info] - IO.race(a, b) should work if `b` completes in typed error

1303[info] - IO.race(a, b) should work if `b` completes in unexpected error

1304[info] - IO.race should be stack safe, take 1

1305[info] - IO.race should be stack safe, take 2

1306[info] - Task.race has a stack safe cancelable

1307[info] monix.bio.tracing.StackTracedContextSuite

1308[info] - push traces

1309[info] - track omitted frames

1310[info] monix.bio.FiberDoctest

1311[info] - Fiber.scala:22: Fiber

1312[info] monix.bio.TaskToFutureSuite

1313[info] - Task.fromFuture for already completed references

1314[info] - Task.deferFuture for already completed references

1315[info] - Task.deferFutureAction for already completed references

1316[info] - Task.fromFuture(error) for already completed references

1317[info] - Task.deferFuture(error) for already completed references

1318[info] - Task.deferFutureAction(typed) for already completed references

1319[info] - Task.fromFuture for completed reference is stack safe (flatMap)

1320[info] - Task.deferFuture for completed reference is stack safe (flatMap)

1321[info] - Task.deferFutureAction for completed reference is stack safe (flatMap)

1322[info] - Task.fromFuture async result

1323[info] - Task.fromFuture(error) async result

1324[info] - Task.deferFuture async result

1325[info] - Task.deferFuture(error) async result

1326[info] - Task.deferFuture(throw error) async result

1327[info] - Task.deferFutureAction async result

1328[info] - Task.deferFutureAction(error) async result

1329[info] - Task.deferFutureAction(throw error) async result

1330[info] - Task.fromFuture(cancelable)

1331[info] - Task.fromFuture(cancelable) is cancelable

1332[info] - Task.deferFuture(cancelable)

1333[info] - Task.deferFuture(cancelable) is cancelable

1334[info] - Task.deferFutureAction(cancelable)

1335[info] - Task.deferFutureAction(cancelable) is cancelable

1336[info] monix.bio.TaskSequenceSuite

1337[info] - IO.sequence should not execute in parallel

1338[info] - IO.sequence should onError if one of the tasks terminates in error

1339[info] - IO.sequence should onTerminate if one of the tasks terminates in error

1340[info] - IO.sequence should be canceled

1341[info] monix.bio.TaskMaterializeSuite

1342[info] - IO.now.materialize

1343[info] - IO.error.materialize

1344[info] - IO.terminate.materialize

1345[info] - IO.evalOnce.materialize should be stack safe

1346[info] - IO.eval.materialize

1347[info] - IO.defer.materialize

1348[info] - IO.defer.flatMap.materialize

1349[info] - IO.flatMap.materialize

1350[info] - IO.evalAsync.materialize

1351[info] - IO.evalAsync.flatMap.materialize

1352[info] - IO.evalAsync(error).flatMap.materialize

1353[info] - IO.now.flatMap(error).materialize

1354[info] - IO.defer(error).materialize

1355[info] - IO.deferTotal(error).materialize

1356[info] - IO.defer(error).flatMap.materialize

1357[info] - IO.now.dematerialize

1358[info] - IO.error.dematerialize

1359[info] - IO.materialize should be stack safe

1360[info] - IO.eval.materialize should work for failure

1361[info] - IO.eval.materialize should be stack safe

1362[info] - IO.now.materialize should work

1363[info] - IO.materialize on failing flatMap

1364[info] - IO.now.materialize should be stack safe

1365[info] - IO.raiseError.dematerialize

1366[info] - IO.terminate.dematerialize

1367[info] monix.bio.TaskConnectionSuite

1368[info] - initial push

1369[info] - cancels Task after being canceled

1370[info] - cancels Cancelable after being canceled

1371[info] - cancels CancelableF after being canceled

1372[info] - push two, pop one

1373[info] - cancel the second time is a no-op

1374[info] - push two, pop two

1375[info] - push(Cancelable)

1376[info] - push(Cancelable) then pop

1377[info] - push(CancelToken)

1378[info] - push(CancelToken) then pop

1379[info] - pop when self is empty

1380[info] - pop when self is canceled

1381[info] - cancel mixture

1382[info] - cancel mixture after being cancelled

1383[info] - tryReactive

1384[info] - toCancelable

1385[info] - uncancelable ref is shared

1386[info] - uncancelable ops

1387[info] - throwing error in Task on cancel all

1388[info] - throwing multiple errors in Tasks on cancel all

1389[info] - throwing error in Task after cancel

1390[info] - throwing error in Cancelable on cancel all

1391[info] - throwing multiple errors in Cancelables on cancel all

1392[info] - throwing error in Cancelable after cancel

1393[info] monix.bio.TaskParTraverseUnorderedSuite

1394[info] - IO.parTraverseUnordered should execute in parallel

1395[info] - IO.parTraverseUnordered should onError if one of the tasks terminates in error

1396[info] - IO.parTraverseUnordered should be canceled

1397[info] - IO.parTraverseUnordered should run over an iterable

1398[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks

1399[info] - IO.parTraverseUnordered should be stack safe on success

1400[info] - IO.parTraverseUnordered should log errors if multiple errors happen

1401[info] - IO.parTraverseUnordered runAsync multiple times

1403[info] monix.bio.TaskAsyncSuite

1404[info] - IO.never should never complete

1405[info] - IO.async should execute

1406[info] - IO.async should signal errors in register

1407[info] - IO.async should be stack safe

1408[info] - IO.async works for immediate successful value

1409[info] - IO.async works for immediate error

1410[info] - IO.async works for immediate terminate error

1411[info] - IO.async is memory safe in flatMap loops

1412[info] - IO.async0 works for immediate successful value

1413[info] - IO.async0 works for async successful value

1414[info] - IO.async0 works for async error

1415[info] - IO.async0 works for async terminate error

1416[info] - IO.async0 is memory safe in synchronous flatMap loops

1417[info] - IO.async0 is memory safe in async flatMap loops

1418[info] monix.bio.TaskLikeConversionsJava8Suite

1419[info] - IO.from converts successful CompletableFuture

1420[info] - IO.from converts failed CompletableFuture

1421[info] - IO.from preserves cancellability of CompletableFuture

1422[info] monix.bio.TaskMemoizeOnSuccessSuite

1423[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber

1424[info] - IO.memoizeOnSuccess should work synchronously for next subscribers

1425[info] - IO.memoizeOnSuccess should be stack safe

1426[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1

1427[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2

1428[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent

1429[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent

1430[info] - IO.memoizeOnSuccess.materialize

1431[info] - IO.raiseError(error).memoizeOnSuccess.materialize

1432[info] - IO.terminate(error).memoizeOnSuccess.materialize

1433[info] - IO.eval.memoizeOnSuccess should work for first subscriber

1434[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers

1435[info] - IO.eval(error).memoizeOnSuccess should not be idempotent

1436[info] - IO.eval.memoizeOnSuccess

1437[info] - IO.eval.memoizeOnSuccess should be stack safe

1438[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe

1439[info] - IO.defer(evalAlways).memoizeOnSuccess

1440[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber

1441[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers

1442[info] - IO.evalOnce(error).memoizeOnSuccess should work

1443[info] - IO.evalOnce.memoizeOnSuccess should be stack safe

1444[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe

1445[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber

1446[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers

1447[info] - IO.raiseError.memoizeOnSuccess should work

1448[info] - IO.terminate.memoizeOnSuccess should work

1449[info] - IO.now.memoizeOnSuccess should be stack safe

1450[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe

1451[info] - IO.suspend.memoizeOnSuccess should be stack safe

1452[info] - IO.memoizeOnSuccess effects, sequential

1453[info] - IO.memoizeOnSuccess effects, parallel

1454[info] - IO.suspend.memoizeOnSuccess effects

1455[info] - IO.suspend.flatMap.memoizeOnSuccess effects

1456[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future

1457[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback

1458[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback

1459[info] - IO.memoizeOnSuccess should be cancellable (future)

1460[info] - IO.memoizeOnSuccess should be cancellable (callback #1)

1461[info] - IO.memoizeOnSuccess should be cancellable (callback #2)

1462[info] - IO.memoizeOnSuccess should not be cancelable

1463[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners

1464[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess

1465[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess

1466[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess

1467[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess

1468[info] - IO.now.memoizeOnSuccess eq IO.now

1469[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError

1470[info] - IO.terminate.memoizeOnSuccess eq IO.terminate

1471[info] monix.bio.TaskEvalAsyncSuite

1472[info] - IO.evalAsync should work, on different thread

1473[info] - IO.evalAsync should protect against user code errors

1474[info] - UIO.evalAsync should protect against user code errors

1475[info] - IO.evalAsync is equivalent with IO.eval

1476[info] - IO.evalAsync is equivalent with IO.evalOnce on first run

1477[info] - IO.evalAsync.flatMap should protect against user code

1478[info] - IO.evalAsync should be tail recursive

1479[info] - IO.evalAsync.flatten is equivalent with flatMap

1480[info] - IO.evalAsync.coeval

1481[info] monix.bio.TaskParSequenceNSuite

1482[info] - IO.parSequenceN should execute in parallel bounded by parallelism

1483[info] - IO.parSequenceN should return result in order

1484[info] - IO.parSequenceN should return empty list

1485[info] - IO.parSequenceN should handle single item

1486[info] - IO.parSequenceN should handle parallelism bigger than list

1487[info] - IO.parSequenceN should onError if one of the tasks terminates in error

1488[info] - IO.parSequenceN should onTerminate if one of the tasks terminates in a fatal error

1489[info] - IO.parSequenceN should be canceled

1490[info] - IO.parSequenceN should be stack safe for synchronous tasks

1491[info] - IO.parSequenceN runAsync multiple times

1492[info] - IO.parSequenceN should log errors if multiple errors happen

1493[info] - IO.parSequenceN should log terminal errors if multiple errors happen

1494Hello World!

1495Cancelling!

1496Received: $value

1497[info] monix.bio.BIOAppSuite

1498[info] - run works

1499[info] - options are configurable

1500[info] - ConcurrentEffect[Task]

1501Hello!

1502Hello!

1503[info] monix.bio.TaskDoOnCancelSuite

1504[info] - doOnCancel should normally mirror the source

1505[info] - doOnCancel should mirror failed sources

1506[info] - doOnCancel should mirror terminated sources

1507[info] - doOnCancel should cancel delayResult #1

1508[info] - doOnCancel should cancel delayResult #2

1509[info] - doOnCancel should cancel delayResult #3

1510[info] - doOnCancel should cancel delayExecution #1

1511[info] - doOnCancel should cancel delayExecution #2

1512[info] - doOnCancel is stack safe in flatMap loops

1513[info] - local.write.doOnCancel works

1514Success: 42

1515[info] monix.bio.TaskExecuteOnSuite

1516[info] - executeOn(forceAsync = false)

1517[info] - executeOn(forceAsync = true)

1518[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1

1519[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2

1520[info] - local.write.executeOn(forceAsync = false) works

1521[info] - local.write.executeOn(forceAsync = true) works

1522[info] monix.bio.IODoctest

1523[info] - IO.scala:52: IO

1524[info] - IO.scala:474: runToFuture

1525[info] - IO.scala:541: runToFutureOpt

1526[info] - IO.scala:586: runAsync

1527[info] - IO.scala:661: runAsyncOpt

1528[info] - IO.scala:716: runAsyncF

1529[info] - IO.scala:821: runAsyncAndForget

1530[info] - IO.scala:874: runAsyncUncancelable

1531[info] - IO.scala:947: runSyncStep

1532[info] - IO.scala:1011: runSyncUnsafe

1533[info] - IO.scala:1116: memoize

1534[info] - IO.scala:1155: memoizeOnSuccess

1535[info] - IO.scala:1213: >>

1536[info] - IO.scala:1226: *>

1537[info] - IO.scala:1242: <*

1538[info] - IO.scala:1257: asyncBoundary

1539[info] - IO.scala:1306: asyncBoundary

1540[info] - IO.scala:1337: bracket

1541[info] - IO.scala:1525: delayExecution

1542[info] - IO.scala:1554: delayResult

1543[info] - IO.scala:1595: executeOn

1544[info] - IO.scala:1730: executeAsync

1545[info] - IO.scala:1756: executeWithModel

1546[info] - IO.scala:1774: executeWithOptions

1547[info] - IO.scala:1801: flip

1548[info] - IO.scala:1831: flipWith

1549[info] - IO.scala:1879: flatMapLoop

1550[info] - IO.scala:1937: loopForever

1551[info] - IO.scala:2008: onCancelRaiseError

1552[info] - IO.scala:2062: mapErrorPartialWith

1553[info] - IO.scala:2113: tapError

1554[info] - IO.scala:2147: onErrorRestartIf

1555[info] - IO.scala:2167: onErrorRestartLoop

1556[info] - IO.scala:2242: mapError

1557[info] - IO.scala:2261: mapErrorPartial

1558[info] - IO.scala:2296: start

1559[info] - IO.scala:2324: to

1560[info] - IO.scala:2366: toConcurrent

1561[info] - IO.scala:2412: toAsync

1562[info] - IO.scala:2536: uncancelable

1563[info] - IO.scala:2559: timed

1564[info] - IO.scala:2608: timeoutToL

1565[info] - IO.scala:2663: hideErrors

1566[info] - IO.scala:2684: hideErrorsWith

1567[info] - IO.scala:2740: absorb

1568[info] - IO.scala:2758: absorbWith

1569[info] - IO.scala:2782: IO

1570[info] - IO.scala:2843: apply

1571[info] - IO.scala:2905: deferAction

1572[info] - IO.scala:2932: deferFuture

1573[info] - IO.scala:2945: deferFutureAction

1574[info] - IO.scala:3082: fromConcurrentEffect

1575[info] - IO.scala:3119: fromEffect

1576[info] - IO.scala:3149: fromOption

1577[info] - IO.scala:3165: fromOption

1578[info] - IO.scala:3185: fromOptionEval

1579[info] - IO.scala:3243: async

1580[info] - IO.scala:3303: async0

1581[info] - IO.scala:3399: cancelable

1582[info] - IO.scala:3479: cancelable0

1583[info] - IO.scala:3581: cancelBoundary

1584[info] - IO.scala:3617: create

1585[info] - IO.scala:3724: race

1586[info] - IO.scala:3757: raceMany

1587[info] - IO.scala:3778: racePair

1588[info] - IO.scala:3861: sleep

1589[info] - IO.scala:3952: parSequence

1590[info] - IO.scala:4011: parSequenceN

1591[info] - IO.scala:4042: parTraverseN

1592[info] - IO.scala:4079: parSequenceUnordered

1593[info] - IO.scala:4127: mapBoth

1594[info] - IO.scala:4146: map2

1595[info] - IO.scala:4175: map3

1596[info] - IO.scala:4205: map4

1597[info] - IO.scala:4238: map5

1598[info] - IO.scala:4276: map6

1599[info] - IO.scala:4316: parMap2

1600[info] - IO.scala:4351: parMap3

1601[info] - IO.scala:4389: parMap4

1602[info] - IO.scala:4430: parMap5

1603[info] - IO.scala:4476: parMap6

1604[info] - IO.scala:4562: liftTo

1605[info] - IO.scala:4622: liftFrom

1606[info] - IO.scala:5282: catsParallel

1607[info] monix.bio.TaskNowSuite

1608[info] - IO.now should work synchronously

1609[info] - IO.now.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

1610[info] - IO.now.runAsync(callback) should work synchronously

1611[info] - IO.now.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

1612[info] - IO.raiseError should work synchronously

1613[info] - IO.terminate should work synchronously

1614[info] - IO.raiseError.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

1615[info] - IO.raiseError.runAsync(callback) should work synchronously

1616[info] - IO.raiseError.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

1617[info] - IO.now.map should work

1618[info] - IO.raiseError.map should be the same as IO.raiseError

1619[info] - IO.raiseError.flatMap should be the same as IO.flatMap

1620[info] - IO.raiseError.flatMap should be protected

1621[info] - IO.now.flatMap should protect against user code

1622[info] - IO.now.flatMap should be tail recursive

1623[info] - IO.now should not be cancelable

1624[info] - IO.raiseError should not be cancelable

1625[info] - IO.terminate should not be cancelable

1626[info] - IO.now.runSyncStep

1627[info] - IO.raiseError.runSyncStep

1628[info] monix.bio.TaskRejectedExecutionSuite

1630[info] monix.bio.TaskClockTimerAndContextShiftSuite

1631[info] - IO.clock is implicit

1632[info] - IO.clock.monotonic

1633[info] - IO.clock.realTime

1634[info] - IO.clock(s2).monotonic

1635[info] - IO.clock(s).realTime

1636[info] - IO.timer is implicit

1637[info] - IO.timer

1638[info] - IO.timer(s)

1639[info] - IO.timer(s).clock

1640[info] - IO.contextShift is implicit

1641[info] - IO.contextShift.shift

1642[info] - IO.contextShift.evalOn(s2)

1643[info] - IO.contextShift.evalOn(s2) failure

1644[info] - IO.contextShift.evalOn(s2) fatal failure

1645[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries

1646[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction

1647[info] - IO.contextShift(s).shift

1648[info] - IO.contextShift(s).evalOn(s2)

1649[info] - IO.contextShift(s).evalOn(s2) failure

1650[info] - IO.contextShift(s).evalOn(s2) fatal failure

1651[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries

1652[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction

1653[info] monix.bio.TaskConnectionCompositeSuite

1654[info] - cancels Cancelable references

1655[info] - cancels Cancelable references after cancel on assignment

1656[info] - cancels Task references

1657[info] - cancels Task references after cancel on assignment

1658[info] - cancels CancelableF references

1659[info] - cancels CancelableF references after cancel on assignment

1660[info] - addAll

1661[info] - remove Task

1662[info] - remove Cancelable

1663[info] - remove CancelableF

1664[info] monix.bio.TaskGuaranteeSuite

1665[info] - finalizer is evaluated on success

1666[info] - finalizer is evaluated on error

1667[info] - finalizer is evaluated on terminal error

1668[info] - if finalizer throws, report finalizer error and signal use error

1669[info] - finalizer is evaluated on cancelation (1)

1670[info] - finalizer is evaluated on cancellation (2)

1671[info] - stack-safety (1)

1672[info] - stack-safety (2)

1673[info] - stack-safety (3)

1674[info] monix.bio.TaskBimapSuite

1675[info] - IO.bimap should map the success channel

1676[info] - IO.bimap should map the error channel

1677[info] monix.bio.TaskAsyncAutoShiftJVMSuite

1678[info] - Task.fromFuture(async) should shift back to the main scheduler

1679[info] - Task.fromFuture(completed) should not shift to the main scheduler

1680[info] - Task.fromFuture(async error) should shift back to the main scheduler

1681[info] - Task.fromFuture(completed error) should not shift to the main scheduler

1682[info] - Task.deferFuture(async) should shift back to the main scheduler

1683[info] - Task.deferFuture(completed) should not shift to the main scheduler

1684[info] - Task.deferFuture(async error) should shift back to the main scheduler

1685[info] - Task.deferFuture(completed error) should not shift to the main scheduler

1686[info] - Task.deferFutureAction(async) should shift back to the main scheduler

1687[info] - Task.deferFutureAction(completed) should not shift to the main scheduler

1688[info] - Task.deferFutureAction(async error) should shift back to the main scheduler

1689[info] - Task.deferFutureAction(completed error) should not shift to the main scheduler

1690[info] - Task.fromFuture(async cancelable) should shift back to the main scheduler

1691[info] - Task.fromFuture(completed cancelable) should not shift to the main scheduler

1692[info] - Task.fromFuture(async error cancelable) should shift back to the main scheduler

1693[info] - Task.fromFuture(completed error cancelable) should not shift to the main scheduler

1694[info] - Task.deferFuture(async cancelable) should shift back to the main scheduler

1695[info] - Task.deferFuture(completed cancelable) should not shift to the main scheduler

1696[info] - Task.deferFuture(async error cancelable) should shift back to the main scheduler

1697[info] - Task.deferFuture(completed error cancelable) should not shift to the main scheduler

1698[info] - Task.deferFutureAction(async cancelable) should shift back to the main scheduler

1699[info] - Task.deferFutureAction(completed cancelable) should not shift to the main scheduler

1700[info] - Task.deferFutureAction(async error cancelable) should shift back to the main scheduler

1701[info] - Task.deferFutureAction(completed error cancelable) should not shift to the main scheduler

1702[info] - Task.async(register) should shift back if register forks

1703[info] - Task.async(register) should not shift back if register does not fork

1704[info] - Task.async(register typed) should shift back if register forks

1705[info] - Task.async(register error) should not shift back if register does not fork

1706[info] - Task.async0(register) should shift back if register forks

1707[info] - Task.async0(register) should not shift back if register does not fork

1708[info] - Task.async0(register error) should shift back if register forks

1709[info] - Task.async0(register error) should not shift back if register does not fork

1710[info] - Task.cancelable(register) should shift back if register forks

1711[info] - Task.cancelable(register) should not shift back if register does not fork

1712[info] - Task.cancelable(register error) should shift back if register forks

1713[info] - Task.cancelable(register error) should not shift back if register does not fork

1714[info] - Task.cancelable0(register) should shift back if register forks

1715[info] - Task.cancelable0(register) should not shift back if register does not fork

1716[info] - Task.cancelable0(register error) should shift back if register forks

1717[info] - Task.cancelable0(register error) should not shift back if register does not fork

1718[info] - Task.create(register) should shift back if register forks

1719[info] - Task.create(register) should not shift back if register does not fork

1720[info] - Task.create(register error) should shift back if register forks

1721[info] - Task.create(register error) should not shift back if register does not fork

1722[info] - Task.asyncF(register) should shift back if register forks

1723[info] - Task.asyncF(register) should not shift back if register does not fork

1724[info] - Task.asyncF(register error) should shift back if register forks

1725[info] - Task.asyncF(register error) should not shift back if register does not fork

1726[info] monix.bio.TaskDelaySuite

1727[info] - IO#delayExecution should work

1728[info] - IO#delayExecution is stack safe, test 1

1729[info] - IO#delayExecution is stack safe, test 2

1730[info] - IO#delayExecution is cancelable

1731[info] - IO#delayResult should work

1732[info] - IO#delayResult is stack safe, test 1

1733[info] - IO#delayResult is stack safe, test 2

1734[info] - IO#delayResult is cancelable

1735[info] - IO#delayResult should not delay in case of error

1736[info] - IO#delayResult should not delay in case of terminal error

1737[info] monix.bio.TaskFromFutureSuite

1738[info] - Task.fromFuture should be faster for completed futures, success

1739[info] - Task.fromFuture should be faster for completed futures, failure

1740[info] - Task.fromFuture should work onSuccess

1741[info] - Task.fromFuture should work onError

1742[info] - Task.fromFuture should be short-circuited onSuccess

1743[info] - Task.fromFuture should be short-circuited onError

1744[info] - Task.fromFuture(cancelable) should work for synchronous results onSuccess

1745[info] - Task.fromFuture(cancelable) should work for synchronous results onFailure

1746[info] - Task.fromFuture(cancelable) should be short-circuited onSuccess

1747[info] - Task.fromFuture(cancelable) should be short-circuited onError

1748[info] - Task.fromFuture(cancelable) should work onSuccess

1749[info] - Task.fromFuture(cancelable) should work onError

1750[info] - Task.fromFuture(cancelable) should be cancelable

1751[info] - Task.fromFuture should be stack safe

1752[info] - Task.now.fromFuture should be stack safe

1753[info] monix.bio.TaskExecuteAsyncSuite

1754[info] - IO.now.executeAsync should execute async

1755[info] - IO.now.executeOn should execute async if forceAsync = true

1756[info] - IO.now.executeOn should not execute async if forceAsync = false

1757[info] - IO.create.executeOn should execute async

1758[info] - executeAsync should be stack safe, test 1

1759[info] - IO.executeOn should be stack safe, test 2

1760[info] - executeAsync should be stack safe, test 3

1761Executing...

1762Received: $str

1763Executing...

1764Executing...

1765Finished via exit code: $exitCode

1766Resources were released!

1767Executing...

1768Received: $str

1769[info] monix.bio.TaskCallbackSafetyJVMSuite

1770[info] - IO.async has a safe callback

1771[info] - IO.async0 has a safe callback

1772[info] - IO.asyncF has a safe callback

1773[info] - IO.cancelable has a safe callback

1774[info] - IO.cancelable0 has a safe callback

1775[info] monix.bio.TaskParTraverseNSuite

1776[info] - IO.parTraverseN allows fully sequential execution

1777[info] - IO.parTraverseN allows fully concurrent execution

1778[info] - IO.parTraverseN allows partially concurrent execution

1779[info] - IO.parTraverseN returns an error when fully sequential execution fails in a typed way

1780[info] - IO.parTraverseN returns an error when fully sequential execution fails in a terminal way

1781[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a typed way

1782[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a terminal way

1783[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a typed way

1784[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a terminal way

1786[info] - IO.parTraverseN should be cancelable

1787[info] - IO.parTraverseN should be stack safe for synchronous tasks with low parallelism

1788[info] - IO.parTraverseN should be stack safe for asynchronous tasks with low parallelism

1789[info] - IO.parTraverseN should be stack safe for synchronous tasks with high parallelism

1790[info] - IO.parTraverseN should be stack safe for asynchronous tasks with high parallelism

1791[info] - IO.parTraverseN allows running the same effect multiple times

1792[info] - IO.parTraverseN allows reusing a memoized effect multiple times

1793[info] monix.bio.TaskEffectInstanceSuite

1794[info] - Effect instance should make use of implicit TaskOptions

1795[info] - Effect instance should use Task.defaultOptions with default TestScheduler

1796[info] - Effect instance should use Task.defaultOptions.withSchedulerFeatures

1797[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite

1798[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1799[info] - CoflatMap[Task].coflatMap.coflatMap identity

1800[info] - CoflatMap[Task].coflatMap.coflatten coherence

1801[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1802[info] - CoflatMap[Task].coflatMap.covariant composition

1803[info] - CoflatMap[Task].coflatMap.covariant identity

1804[info] - CoflatMap[Task].coflatMap.invariant composition

1805[info] - CoflatMap[Task].coflatMap.invariant identity

1806[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

1807[info] - Concurrent[Task].async.ap consistent with product + map

1808[info] - Concurrent[Task].async.applicative homomorphism

1809[info] - Concurrent[Task].async.applicative identity

1810[info] - Concurrent[Task].async.applicative interchange

1811[info] - Concurrent[Task].async.applicative map

1812[info] - Concurrent[Task].async.applicative unit

1813[info] - Concurrent[Task].async.applicativeError adaptError pure

1814[info] - Concurrent[Task].async.applicativeError adaptError raise

1815[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

1816[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

1817[info] - Concurrent[Task].async.applicativeError handle

1818[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

1819[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

1820[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

1821[info] - Concurrent[Task].async.applicativeError handleError pure

1822[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

1823[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

1824[info] - Concurrent[Task].async.applicativeError handleWith

1825[info] - Concurrent[Task].async.applicativeError onError pure

1826[info] - Concurrent[Task].async.applicativeError onError raise

1827[info] - Concurrent[Task].async.applicativeError pure attempt

1828[info] - Concurrent[Task].async.applicativeError raiseError attempt

1829[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

1830[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

1831[info] - Concurrent[Task].async.apply composition

1832[info] - Concurrent[Task].async.async can be derived from asyncF

1833[info] - Concurrent[Task].async.async left is raiseError

1834[info] - Concurrent[Task].async.async right is pure

1835[info] - Concurrent[Task].async.bind suspends evaluation

1836[info] - Concurrent[Task].async.bracket is derived from bracketCase

1837[info] - Concurrent[Task].async.bracket release is called on Completed or Error

1838[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

1839[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

1840[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1841[info] - Concurrent[Task].async.covariant composition

1842[info] - Concurrent[Task].async.covariant identity

1843[info] - Concurrent[Task].async.delay constant is pure

1844[info] - Concurrent[Task].async.flatMap associativity

1845[info] - Concurrent[Task].async.flatMap consistent apply

1846[info] - Concurrent[Task].async.flatMap from tailRecM consistency

1847[info] - Concurrent[Task].async.guarantee is derived from bracket

1848[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

1849[info] - Concurrent[Task].async.invariant composition

1850[info] - Concurrent[Task].async.invariant identity

1851[info] - Concurrent[Task].async.map flatMap coherence

1852[info] - Concurrent[Task].async.map suspends evaluation

1853[info] - Concurrent[Task].async.map2/map2Eval consistency

1854[info] - Concurrent[Task].async.map2/product-map consistency

1855[info] - Concurrent[Task].async.monad left identity

1856[info] - Concurrent[Task].async.monad right identity

1857[info] - Concurrent[Task].async.monadError ensure consistency

1858[info] - Concurrent[Task].async.monadError ensureOr consistency

1859[info] - Concurrent[Task].async.monadError left zero

1860[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

1861[info] - Concurrent[Task].async.monadError rethrow attempt

1862[info] - Concurrent[Task].async.monoidal left identity

1863[info] - Concurrent[Task].async.monoidal right identity

1864[info] - Concurrent[Task].async.mproduct consistent flatMap

1865[info] - Concurrent[Task].async.never is derived from async

1866[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

1867[info] - Concurrent[Task].async.productL consistent map2

1868[info] - Concurrent[Task].async.productR consistent map2

1869[info] - Concurrent[Task].async.propagate errors through bind (async)

1870[info] - Concurrent[Task].async.propagate errors through bind (suspend)

1871[info] - Concurrent[Task].async.repeated async evaluation not memoized

1872[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

1873[info] - Concurrent[Task].async.repeated sync evaluation not memoized

1874[info] - Concurrent[Task].async.semigroupal associativity

1875[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

1876[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

1877[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

1878[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

1879[info] - Concurrent[Task].async.stack-safe on left-associated binds

1880[info] - Concurrent[Task].async.stack-safe on repeated attempts

1881[info] - Concurrent[Task].async.stack-safe on repeated maps

1882[info] - Concurrent[Task].async.stack-safe on right-associated binds

1883[info] - Concurrent[Task].async.suspend constant is pure join

1884[info] - Concurrent[Task].async.tailRecM consistent flatMap

1885[info] - Concurrent[Task].async.tailRecM stack safety

1886[info] - Concurrent[Task].async.throw in delay is raiseError

1887[info] - Concurrent[Task].async.throw in suspend is raiseError

1888[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

1889[info] - Concurrent[Task].async.unsequenced delay is no-op

1890[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

1891[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

1892[info] - ConcurrentEffect[Task].effect.applicative homomorphism

1893[info] - ConcurrentEffect[Task].effect.applicative identity

1894[info] - ConcurrentEffect[Task].effect.applicative interchange

1895[info] - ConcurrentEffect[Task].effect.applicative map

1896[info] - ConcurrentEffect[Task].effect.applicative unit

1897[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

1898[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

1899[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

1900[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

1901[info] - ConcurrentEffect[Task].effect.applicativeError handle

1902[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

1903[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

1904[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

1905[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

1906[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

1907[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

1908[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

1909[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

1910[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

1911[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

1912[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

1913[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

1914[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

1915[info] - ConcurrentEffect[Task].effect.apply composition

1916[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

1917[info] - ConcurrentEffect[Task].effect.async left is raiseError

1918[info] - ConcurrentEffect[Task].effect.async right is pure

1919[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

1920[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

1921[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

1922[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

1923[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

1924[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1925[info] - ConcurrentEffect[Task].effect.covariant composition

1926[info] - ConcurrentEffect[Task].effect.covariant identity

1927[info] - ConcurrentEffect[Task].effect.delay constant is pure

1928[info] - ConcurrentEffect[Task].effect.flatMap associativity

1929[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

1930[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

1931[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

1932[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

1933[info] - ConcurrentEffect[Task].effect.invariant composition

1934[info] - ConcurrentEffect[Task].effect.invariant identity

1935[info] - ConcurrentEffect[Task].effect.map flatMap coherence

1936[info] - ConcurrentEffect[Task].effect.map suspends evaluation

1937[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

1938[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

1939[info] - ConcurrentEffect[Task].effect.monad left identity

1940[info] - ConcurrentEffect[Task].effect.monad right identity

1941[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

1942[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

1943[info] - ConcurrentEffect[Task].effect.monadError left zero

1944[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

1945[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

1946[info] - ConcurrentEffect[Task].effect.monoidal left identity

1947[info] - ConcurrentEffect[Task].effect.monoidal right identity

1948[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

1949[info] - ConcurrentEffect[Task].effect.never is derived from async

1950[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

1951[info] - ConcurrentEffect[Task].effect.productL consistent map2

1952[info] - ConcurrentEffect[Task].effect.productR consistent map2

1953[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

1954[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

1955[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

1956[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

1957[info] - ConcurrentEffect[Task].effect.repeated callback ignored

1958[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

1959[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

1960[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

1961[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

1962[info] - ConcurrentEffect[Task].effect.semigroupal associativity

1963[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

1964[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

1965[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

1966[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

1967[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

1968[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

1969[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

1970[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

1971[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

1972[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

1973[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

1974[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

1975[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

1976[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

1977[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

1978[info] - ConcurrentEffect[Task].effect.toIO stack safety

1979[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

1980[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

1981[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

1982[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

1983[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

1984[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

1985[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

1986[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

1987[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

1988[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

1989[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

1990[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

1991[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

1992[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

1993[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

1994[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

1995[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

1996[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

1997[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

1998[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

1999[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2000[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2001[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2002[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2003[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2004[info] - Monoid[IO[Throwable, Int]].monoid.associative

2005[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2006[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2007[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2008[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2009[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2010[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2011[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2012[info] - Monoid[IO[Throwable, Int]].monoid.is id

2013[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2014[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2015[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2016[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2017[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2018[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2019[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2020[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2021[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2022[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2023[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2024[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2025[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2026[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite

2027[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2028[info] - CoflatMap[Task].coflatMap.coflatMap identity

2029[info] - CoflatMap[Task].coflatMap.coflatten coherence

2030[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2031[info] - CoflatMap[Task].coflatMap.covariant composition

2032[info] - CoflatMap[Task].coflatMap.covariant identity

2033[info] - CoflatMap[Task].coflatMap.invariant composition

2034[info] - CoflatMap[Task].coflatMap.invariant identity

2035[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

2036[info] - Concurrent[Task].async.ap consistent with product + map

2037[info] - Concurrent[Task].async.applicative homomorphism

2038[info] - Concurrent[Task].async.applicative identity

2039[info] - Concurrent[Task].async.applicative interchange

2040[info] - Concurrent[Task].async.applicative map

2041[info] - Concurrent[Task].async.applicative unit

2042[info] - Concurrent[Task].async.applicativeError adaptError pure

2043[info] - Concurrent[Task].async.applicativeError adaptError raise

2044[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

2045[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

2046[info] - Concurrent[Task].async.applicativeError handle

2047[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

2048[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

2049[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

2050[info] - Concurrent[Task].async.applicativeError handleError pure

2051[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

2052[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

2053[info] - Concurrent[Task].async.applicativeError handleWith

2054[info] - Concurrent[Task].async.applicativeError onError pure

2055[info] - Concurrent[Task].async.applicativeError onError raise

2056[info] - Concurrent[Task].async.applicativeError pure attempt

2057[info] - Concurrent[Task].async.applicativeError raiseError attempt

2058[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

2059[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

2060[info] - Concurrent[Task].async.apply composition

2061[info] - Concurrent[Task].async.async can be derived from asyncF

2062[info] - Concurrent[Task].async.async left is raiseError

2063[info] - Concurrent[Task].async.async right is pure

2064[info] - Concurrent[Task].async.bind suspends evaluation

2065[info] - Concurrent[Task].async.bracket is derived from bracketCase

2066[info] - Concurrent[Task].async.bracket release is called on Completed or Error

2067[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

2068[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

2069[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2070[info] - Concurrent[Task].async.covariant composition

2071[info] - Concurrent[Task].async.covariant identity

2072[info] - Concurrent[Task].async.delay constant is pure

2073[info] - Concurrent[Task].async.flatMap associativity

2074[info] - Concurrent[Task].async.flatMap consistent apply

2075[info] - Concurrent[Task].async.flatMap from tailRecM consistency

2076[info] - Concurrent[Task].async.guarantee is derived from bracket

2077[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

2078[info] - Concurrent[Task].async.invariant composition

2079[info] - Concurrent[Task].async.invariant identity

2080[info] - Concurrent[Task].async.map flatMap coherence

2081[info] - Concurrent[Task].async.map suspends evaluation

2082[info] - Concurrent[Task].async.map2/map2Eval consistency

2083[info] - Concurrent[Task].async.map2/product-map consistency

2084[info] - Concurrent[Task].async.monad left identity

2085[info] - Concurrent[Task].async.monad right identity

2086[info] - Concurrent[Task].async.monadError ensure consistency

2087[info] - Concurrent[Task].async.monadError ensureOr consistency

2088[info] - Concurrent[Task].async.monadError left zero

2089[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

2090[info] - Concurrent[Task].async.monadError rethrow attempt

2091[info] - Concurrent[Task].async.monoidal left identity

2092[info] - Concurrent[Task].async.monoidal right identity

2093[info] - Concurrent[Task].async.mproduct consistent flatMap

2094[info] - Concurrent[Task].async.never is derived from async

2095[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

2096[info] - Concurrent[Task].async.productL consistent map2

2097[info] - Concurrent[Task].async.productR consistent map2

2098[info] - Concurrent[Task].async.propagate errors through bind (async)

2099[info] - Concurrent[Task].async.propagate errors through bind (suspend)

2100[info] - Concurrent[Task].async.repeated async evaluation not memoized

2101[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

2102[info] - Concurrent[Task].async.repeated sync evaluation not memoized

2103[info] - Concurrent[Task].async.semigroupal associativity

2104[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

2105[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

2106[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

2107[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

2108[info] - Concurrent[Task].async.stack-safe on left-associated binds

2109[info] - Concurrent[Task].async.stack-safe on repeated attempts

2110[info] - Concurrent[Task].async.stack-safe on repeated maps

2111[info] - Concurrent[Task].async.stack-safe on right-associated binds

2112[info] - Concurrent[Task].async.suspend constant is pure join

2113[info] - Concurrent[Task].async.tailRecM consistent flatMap

2114[info] - Concurrent[Task].async.tailRecM stack safety

2115[info] - Concurrent[Task].async.throw in delay is raiseError

2116[info] - Concurrent[Task].async.throw in suspend is raiseError

2117[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

2118[info] - Concurrent[Task].async.unsequenced delay is no-op

2119[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

2120[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

2121[info] - ConcurrentEffect[Task].effect.applicative homomorphism

2122[info] - ConcurrentEffect[Task].effect.applicative identity

2123[info] - ConcurrentEffect[Task].effect.applicative interchange

2124[info] - ConcurrentEffect[Task].effect.applicative map

2125[info] - ConcurrentEffect[Task].effect.applicative unit

2126[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

2127[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

2128[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

2129[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

2130[info] - ConcurrentEffect[Task].effect.applicativeError handle

2131[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

2132[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

2133[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

2134[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

2135[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

2136[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

2137[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

2138[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

2139[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

2140[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

2141[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

2142[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

2143[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

2144[info] - ConcurrentEffect[Task].effect.apply composition

2145[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

2146[info] - ConcurrentEffect[Task].effect.async left is raiseError

2147[info] - ConcurrentEffect[Task].effect.async right is pure

2148[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

2149[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

2150[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

2151[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

2152[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

2153[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2154[info] - ConcurrentEffect[Task].effect.covariant composition

2155[info] - ConcurrentEffect[Task].effect.covariant identity

2156[info] - ConcurrentEffect[Task].effect.delay constant is pure

2157[info] - ConcurrentEffect[Task].effect.flatMap associativity

2158[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

2159[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

2160[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

2161[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

2162[info] - ConcurrentEffect[Task].effect.invariant composition

2163[info] - ConcurrentEffect[Task].effect.invariant identity

2164[info] - ConcurrentEffect[Task].effect.map flatMap coherence

2165[info] - ConcurrentEffect[Task].effect.map suspends evaluation

2166[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

2167[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

2168[info] - ConcurrentEffect[Task].effect.monad left identity

2169[info] - ConcurrentEffect[Task].effect.monad right identity

2170[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

2171[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

2172[info] - ConcurrentEffect[Task].effect.monadError left zero

2173[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

2174[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

2175[info] - ConcurrentEffect[Task].effect.monoidal left identity

2176[info] - ConcurrentEffect[Task].effect.monoidal right identity

2177[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

2178[info] - ConcurrentEffect[Task].effect.never is derived from async

2179[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

2180[info] - ConcurrentEffect[Task].effect.productL consistent map2

2181[info] - ConcurrentEffect[Task].effect.productR consistent map2

2182[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

2183[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

2184[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

2185[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

2186[info] - ConcurrentEffect[Task].effect.repeated callback ignored

2187[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

2188[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

2189[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

2190[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

2191[info] - ConcurrentEffect[Task].effect.semigroupal associativity

2192[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

2193[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

2194[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

2195[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

2196[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

2197[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

2198[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

2199[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

2200[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

2201[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

2202[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

2203[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

2204[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

2205[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

2206[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

2207[info] - ConcurrentEffect[Task].effect.toIO stack safety

2208[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

2209[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

2210[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2211[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2212[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2213[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2214[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2215[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2216[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2217[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2218[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2219[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2220[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2221[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2222[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2223[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2224[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2225[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2226[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2227[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2228[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2229[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2230[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2231[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2232[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2233[info] - Monoid[IO[Throwable, Int]].monoid.associative

2234[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2235[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2236[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2237[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2238[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2239[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2240[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2241[info] - Monoid[IO[Throwable, Int]].monoid.is id

2242[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2243[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2244[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2245[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2246[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2247[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2248[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2249[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2250[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2251[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2252[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2253[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2254[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2255[info] monix.bio.TaskParSequenceSuite

2256[info] - IO.parSequence should execute in parallel for async tasks

2257[info] - IO.parSequence should onError if one of the tasks terminates in error

2258[info] - IO.parSequence should onTerminate if one of the tasks terminates in a fatal error

2259[info] - IO.parSequence should be canceled

2260[info] - IO.parSequence should be stack safe for synchronous tasks

2261[info] - IO.parSequence runAsync multiple times

2262[info] - IO.parSequence should log errors if multiple errors happen

2263[info] - IO.parSequence should log terminal errors if multiple errors happen

2264[info] monix.bio.TaskCancellationSuite

2265[info] - cancellation works for async actions

2266[info] - cancellation works for autoCancelableRunLoops

2267[info] - task.start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> UIO.never

2268[info] - uncancelable works for async actions

2269[info] - uncancelable works for autoCancelableRunLoops

2270[info] - uncancelable is stack safe in flatMap loop, take 1

2271[info] - uncancelable is stack safe in flatMap loop, take 2

2272[info] - fa.onCancelRaiseError <-> fa

2273[info] - fa.onCancelRaiseError(e).start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> raiseError(e)

2274[info] - cancelBoundary happy path

2275[info] - cancelBoundary execution is immediate

2276[info] - cancelBoundary is stack safe

2277[info] - cancelBoundary cancels

2278[info] - onCancelRaiseError resets cancellation flag

2279[info] - errors raised after cancel get reported

2280[info] - terminal errors raised after cancel get reported

2281[info] - onCancelRaiseError is stack safe in flatMap loop, take 1

2282[info] - onCancelRaiseError is stack safe in flatMap loop, take 2

2283[info] - local.write.uncancelable works

2284[info] - local.write.onCancelRaiseError works

2285[info] monix.bio.TaskStartSuite

2286[info] - task.start.flatMap(_.join) <-> task

2287[info] - task.start.flatMap(id) is cancelable, but the source is memoized

2288[info] - task.start is stack safe

2289[info] - task.start shares Local.Context with fibers

2290[info] - task.start is stack safe

2291[info] - task.start executes asynchronously

2292value1: 0

2293value2: 100

2294value3: 400

2295value4: 100

2296value5: 0

2297[info] monix.bio.IOLocalDoctest

2298[info] - IOLocal.scala:23: IOLocal

2299[info] - IOLocal.scala:124: bind

2300[info] - IOLocal.scala:148: bindL

2301[info] - IOLocal.scala:179: bindClear

2302[info] monix.bio.IOStartAndForgetSuite

2303[info] - IO#startAndForget triggers execution in background thread

2304[info] - IO#startAndForget does not affect execution of main thread with raised errors

2305[info] - IO#startAndForget triggers fatal errors in background thread

2306[info] - IO#startAndForget is stack safe

2307[info] monix.bio.TaskConnectionRefSuite

2308[info] - assign and cancel a Cancelable

2309[info] - assign and cancel a CancelableF

2310[info] - assign and cancel a CancelToken[Task]

2311[info] - cancel a Cancelable on single assignment

2312[info] - cancel a CancelableF on single assignment

2313[info] - cancel a Task on single assignment

2314[info] monix.bio.TaskTraverseSuite

2315[info] - IO.traverse should not execute in parallel

2316[info] - IO.traverse should onError if one of the tasks terminates in error

2317[info] - IO.traverse should onError if one of the tasks terminates in error

2318[info] - IO.traverse should be canceled

2319[info] monix.bio.TaskTerminationSuite

2320[info] - IO#redeemCause should mirror source on success

2321[info] - IO#redeemCause should recover typed error

2322[info] - IO#redeemCause should recover unexpected error

2323[info] - IO#redeemCause should protect against user code

2324[info] - IO#redeemCauseWith derives flatMap

2325[info] - IO#redeemCauseWith should mirror source on success

2326[info] - IO#redeemCauseWith should recover typed error

2327[info] - IO#redeemCauseWith should recover unexpected error

2328[info] - IO#redeemCauseWith should protect against user code

2329[info] monix.bio.TaskParSequenceUnorderedSuite

2330[info] - IO.parSequenceUnordered should execute in parallel

2331[info] - IO.parSequenceUnordered should onError if one of the tasks terminates in error

2332[info] - IO.parSequenceUnordered should onTerminate if one of the tasks terminates in a fatal error

2333[info] - IO.parSequenceUnordered should be canceled

2334[info] - IO.parSequenceUnordered should run over an iterable

2335[info] - IO.parSequenceUnordered should be stack-safe on handling many tasks

2336[info] - IO.parSequenceUnordered should be stack safe on success

2337[info] - IO.parSequenceUnordered should log errors if multiple errors happen

2338[info] - IO.parSequenceUnordered should log terminal errors if multiple errors happen

2339[info] - IO.parSequenceUnordered runAsync multiple times

2340[info] monix.bio.IOFromFutureEitherSuite

2341[info] - IO.fromFutureEither should return success channel for Right

2342[info] - IO.fromFutureEither should return checked failure channel for Left

2343[info] - IO.fromFutureEither should return unchecked failure channel for a failed Future

2344[info] - IO.fromFutureEither(cancelable) should work for Right synchronous results onSuccess

2345[info] - IO.fromFutureEither(cancelable) should work for Left synchronous results onSuccess

2346[info] - IO.fromFutureEither(cancelable) should work for synchronous results onFailure

2347[info] - IO.fromFutureEither(cancelable) should be short-circuited for Right onSuccess

2348[info] - IO.fromFutureEither(cancelable) should be short-circuited for Left onSuccess

2349[info] - IO.fromFutureEither(cancelable) should be short-circuited onError

2350[info] - IO.fromFutureEither(cancelable) should work onSuccess

2351[info] - IO.fromFutureEither(cancelable) should work onError

2352[info] - IO.fromFutureEither(cancelable) should be cancelable

2353[info] - IO.fromFutureEither should be stack safe

2354[info] monix.bio.TaskVoidSuite

2355[info] - IO.void should work

2356Hello!

2357[info] monix.bio.TaskMemoizeSuite

2358[info] - IO.memoize should work asynchronously for first subscriber

2359[info] - IO.memoize should work synchronously for next subscribers

2360[info] - IO.memoize should be stack safe

2361[info] - IO.flatMap.memoize should be stack safe, test 1

2362[info] - IO.flatMap.memoize should be stack safe, test 2

2363[info] - IO.raiseError(error).memoize should work

2364[info] - IO.terminate(error).memoize should work

2365[info] - IO.memoize.materialize

2366[info] - IO.apply(error).memoize.materialize

2367[info] - IO.eval.memoize should work for first subscriber

2368[info] - IO.eval.memoize should work synchronously for next subscribers

2369[info] - IO.eval(error).memoize should work

2370[info] - IO.eval.memoize

2371[info] - IO.eval.memoize should be stack safe

2372[info] - IO.eval.flatMap.memoize should be stack safe

2373[info] - IO.defer(evalAlways).memoize

2374[info] - IO.evalOnce.memoize should work for first subscriber

2375[info] - IO.evalOnce.memoize should work synchronously for next subscribers

2376[info] - IO.evalOnce(error).memoize should work

2377[info] - IO.evalOnce.memoize should be stack safe

2378[info] - IO.evalOnce.flatMap.memoize should be stack safe

2379[info] - IO.now.memoize should work synchronously for first subscriber

2380[info] - IO.now.memoize should work synchronously for next subscribers

2381[info] - IO.error.memoize should work

2382[info] - IO.now.memoize should be stack safe

2383[info] - IO.now.flatMap.memoize should be stack safe

2384[info] - IO.defer.memoize should be stack safe

2385[info] - IO.memoize effects, sequential

2386[info] - IO.memoize effects, parallel

2387[info] - IO.suspend.memoize effects

2388[info] - IO.suspend.flatMap.memoize effects

2389[info] - IO.memoize should make subsequent subscribers wait for the result, as future

2390[info] - IO.memoize should make subsequent subscribers wait for the result, as callback

2391[info] - Task.memoize should be synchronous for subsequent subscribers, as callback

2392[info] - IO.memoize should not be cancelable (future)

2393[info] - IO.memoize should be cancelable (callback, #1)

2394[info] - IO.memoize should be cancelable (callback, #2)

2395[info] - IO.memoize should be re-executable after cancel

2396[info] - IO.memoize should not be uninterruptible

2397[info] - IO.memoize serves error after async boundary

2398[info] - TaskRunLoop.startLightWithBiCallback for success

2399[info] - TaskRunLoop.startLightWithBiCallback for failure

2400[info] - IO.evalOnce eq IO.evalOnce.memoize

2401[info] - IO.eval.memoize eq IO.eval.memoize.memoize

2402[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoize

2403[info] - IO.now.memoize eq IO.now

2404[info] - IO.raiseError.memoize eq IO.raiseError

2405[info] - IO.terminate.memoize eq IO.raiseError

2406[info] - IO.eval.memoizeOnSuccess.memoize !== IO.eval.memoizeOnSuccess

2407[info] monix.bio.TypeClassLawsForTaskSuite

2408[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2409[info] - CoflatMap[Task].coflatMap.coflatMap identity

2410[info] - CoflatMap[Task].coflatMap.coflatten coherence

2411[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2412[info] - CoflatMap[Task].coflatMap.covariant composition

2413[info] - CoflatMap[Task].coflatMap.covariant identity

2414[info] - CoflatMap[Task].coflatMap.invariant composition

2415[info] - CoflatMap[Task].coflatMap.invariant identity

2416[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2417[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2418[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2419[info] - Concurrent[Task].concurrent.ap consistent with product + map

2420[info] - Concurrent[Task].concurrent.applicative homomorphism

2421[info] - Concurrent[Task].concurrent.applicative identity

2422[info] - Concurrent[Task].concurrent.applicative interchange

2423[info] - Concurrent[Task].concurrent.applicative map

2424[info] - Concurrent[Task].concurrent.applicative unit

2425[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2426[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2427[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2428[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2429[info] - Concurrent[Task].concurrent.applicativeError handle

2430[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2431[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2432[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2433[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2434[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2435[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2436[info] - Concurrent[Task].concurrent.applicativeError handleWith

2437[info] - Concurrent[Task].concurrent.applicativeError onError pure

2438[info] - Concurrent[Task].concurrent.applicativeError onError raise

2439[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2440[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2441[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2442[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2443[info] - Concurrent[Task].concurrent.apply composition

2444[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2445[info] - Concurrent[Task].concurrent.async cancelable coherence

2446[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2447[info] - Concurrent[Task].concurrent.async left is raiseError

2448[info] - Concurrent[Task].concurrent.async right is pure

2449[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2450[info] - Concurrent[Task].concurrent.bind suspends evaluation

2451[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2452[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2453[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2454[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2455[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2456[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2457[info] - Concurrent[Task].concurrent.covariant composition

2458[info] - Concurrent[Task].concurrent.covariant identity

2459[info] - Concurrent[Task].concurrent.delay constant is pure

2460[info] - Concurrent[Task].concurrent.flatMap associativity

2461[info] - Concurrent[Task].concurrent.flatMap consistent apply

2462[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2463[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2464[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2465[info] - Concurrent[Task].concurrent.invariant composition

2466[info] - Concurrent[Task].concurrent.invariant identity

2467[info] - Concurrent[Task].concurrent.join is idempotent

2468[info] - Concurrent[Task].concurrent.map flatMap coherence

2469[info] - Concurrent[Task].concurrent.map suspends evaluation

2470[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2471[info] - Concurrent[Task].concurrent.map2/product-map consistency

2472[info] - Concurrent[Task].concurrent.monad left identity

2473[info] - Concurrent[Task].concurrent.monad right identity

2474[info] - Concurrent[Task].concurrent.monadError ensure consistency

2475[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2476[info] - Concurrent[Task].concurrent.monadError left zero

2477[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2478[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2479[info] - Concurrent[Task].concurrent.monoidal left identity

2480[info] - Concurrent[Task].concurrent.monoidal right identity

2481[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2482[info] - Concurrent[Task].concurrent.never is derived from async

2483[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2484[info] - Concurrent[Task].concurrent.productL consistent map2

2485[info] - Concurrent[Task].concurrent.productR consistent map2

2486[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2487[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2488[info] - Concurrent[Task].concurrent.race cancels both

2489[info] - Concurrent[Task].concurrent.race cancels loser

2490[info] - Concurrent[Task].concurrent.race mirrors left winner

2491[info] - Concurrent[Task].concurrent.race mirrors right winner

2492[info] - Concurrent[Task].concurrent.racePair can join left

2493[info] - Concurrent[Task].concurrent.racePair can join right

2494[info] - Concurrent[Task].concurrent.racePair cancels both

2495[info] - Concurrent[Task].concurrent.racePair cancels loser

2496[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2497[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2498[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2499[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2500[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2501[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2502[info] - Concurrent[Task].concurrent.semigroupal associativity

2503[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2504[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2505[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2506[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2507[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2508[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2509[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2510[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2511[info] - Concurrent[Task].concurrent.start then join is identity

2512[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2513[info] - Concurrent[Task].concurrent.suspend constant is pure join

2514[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2515[info] - Concurrent[Task].concurrent.tailRecM stack safety

2516[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2517[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2518[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2519[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2520[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2521[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2522[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2523[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2524[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2525[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2526[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2527[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2528[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2529[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2530[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2531[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2532[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2533[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2534[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2535[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2536[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2537[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2538[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2539[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2540[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2541[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2542[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2543[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2544[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2545[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2546[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2547[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2548[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2549[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2550[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2551[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2552[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2553[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2554[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2555[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2556[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2557[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2558[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2559[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2560[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2561[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2562[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2563[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2564[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2565[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2566[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2567[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2568[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2569[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2570[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2571[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2572[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2573[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2574[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2575[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2576[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2577[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2578[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2579[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2580[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2581[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2582[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2583[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2584[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2585[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2586[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2587[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2588[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2589[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2590[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2591[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2592[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2593[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2594[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2595[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2596[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2597[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2598[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2599[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2600[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2601[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2602[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2603[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2604[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2605[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2606[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2607[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2608[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2609[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2610[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2611[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2612[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2613[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2614[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2615[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2616[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2617[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2618[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2619[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2620[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2621[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2622[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2623[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2624[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2625[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2626[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2627[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2628[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2629[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2630[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2631[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2632[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2633[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2634[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2635[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2636[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2637[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2638[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2639[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2640[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2641[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2642[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2643[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2644[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2645[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2646[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2647[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2648[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2649[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2650[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2651[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2652[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2653[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2654[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2655[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2656[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2657[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2658[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2659[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2660[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2661[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2662[info] - Monoid[IO[String, Int]].monoid.associative

2663[info] - Monoid[IO[String, Int]].monoid.collect0

2664[info] - Monoid[IO[String, Int]].monoid.combine all

2665[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2666[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2667[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2668[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2669[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2670[info] - Monoid[IO[String, Int]].monoid.is id

2671[info] - Monoid[IO[String, Int]].monoid.left identity

2672[info] - Monoid[IO[String, Int]].monoid.repeat0

2673[info] - Monoid[IO[String, Int]].monoid.repeat1

2674[info] - Monoid[IO[String, Int]].monoid.repeat2

2675[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2676[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2677[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2678[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2679[info] - Monoid[IO[String, Int]].monoid.right identity

2680[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2681[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2682[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2683[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2684[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2685[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite

2686[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2687[info] - CoflatMap[Task].coflatMap.coflatMap identity

2688[info] - CoflatMap[Task].coflatMap.coflatten coherence

2689[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2690[info] - CoflatMap[Task].coflatMap.covariant composition

2691[info] - CoflatMap[Task].coflatMap.covariant identity

2692[info] - CoflatMap[Task].coflatMap.invariant composition

2693[info] - CoflatMap[Task].coflatMap.invariant identity

2694[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2695[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2696[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2697[info] - Concurrent[Task].concurrent.ap consistent with product + map

2698[info] - Concurrent[Task].concurrent.applicative homomorphism

2699[info] - Concurrent[Task].concurrent.applicative identity

2700[info] - Concurrent[Task].concurrent.applicative interchange

2701[info] - Concurrent[Task].concurrent.applicative map

2702[info] - Concurrent[Task].concurrent.applicative unit

2703[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2704[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2705[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2706[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2707[info] - Concurrent[Task].concurrent.applicativeError handle

2708[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2709[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2710[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2711[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2712[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2713[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2714[info] - Concurrent[Task].concurrent.applicativeError handleWith

2715[info] - Concurrent[Task].concurrent.applicativeError onError pure

2716[info] - Concurrent[Task].concurrent.applicativeError onError raise

2717[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2718[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2719[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2720[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2721[info] - Concurrent[Task].concurrent.apply composition

2722[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2723[info] - Concurrent[Task].concurrent.async cancelable coherence

2724[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2725[info] - Concurrent[Task].concurrent.async left is raiseError

2726[info] - Concurrent[Task].concurrent.async right is pure

2727[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2728[info] - Concurrent[Task].concurrent.bind suspends evaluation

2729[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2730[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2731[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2732[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2733[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2734[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2735[info] - Concurrent[Task].concurrent.covariant composition

2736[info] - Concurrent[Task].concurrent.covariant identity

2737[info] - Concurrent[Task].concurrent.delay constant is pure

2738[info] - Concurrent[Task].concurrent.flatMap associativity

2739[info] - Concurrent[Task].concurrent.flatMap consistent apply

2740[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2741[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2742[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2743[info] - Concurrent[Task].concurrent.invariant composition

2744[info] - Concurrent[Task].concurrent.invariant identity

2745[info] - Concurrent[Task].concurrent.join is idempotent

2746[info] - Concurrent[Task].concurrent.map flatMap coherence

2747[info] - Concurrent[Task].concurrent.map suspends evaluation

2748[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2749[info] - Concurrent[Task].concurrent.map2/product-map consistency

2750[info] - Concurrent[Task].concurrent.monad left identity

2751[info] - Concurrent[Task].concurrent.monad right identity

2752[info] - Concurrent[Task].concurrent.monadError ensure consistency

2753[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2754[info] - Concurrent[Task].concurrent.monadError left zero

2755[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2756[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2757[info] - Concurrent[Task].concurrent.monoidal left identity

2758[info] - Concurrent[Task].concurrent.monoidal right identity

2759[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2760[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2761[info] - Concurrent[Task].concurrent.productL consistent map2

2762[info] - Concurrent[Task].concurrent.productR consistent map2

2763[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2764[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2765[info] - Concurrent[Task].concurrent.race cancels both

2766[info] - Concurrent[Task].concurrent.race cancels loser

2767[info] - Concurrent[Task].concurrent.race mirrors left winner

2768[info] - Concurrent[Task].concurrent.race mirrors right winner

2769[info] - Concurrent[Task].concurrent.racePair can join left

2770[info] - Concurrent[Task].concurrent.racePair can join right

2771[info] - Concurrent[Task].concurrent.racePair cancels both

2772[info] - Concurrent[Task].concurrent.racePair cancels loser

2773[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2774[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2775[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2776[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2777[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2778[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2779[info] - Concurrent[Task].concurrent.semigroupal associativity

2780[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2781[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2782[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2783[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2784[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2785[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2786[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2787[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2788[info] - Concurrent[Task].concurrent.start then join is identity

2789[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2790[info] - Concurrent[Task].concurrent.suspend constant is pure join

2791[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2792[info] - Concurrent[Task].concurrent.tailRecM stack safety

2793[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2794[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2795[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2796[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2797[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2798[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2799[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2800[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2801[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2802[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2803[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2804[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2805[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2806[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2807[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2808[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2809[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2810[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2811[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2812[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2813[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2814[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2815[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2816[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2817[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2818[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2819[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2820[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2821[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2822[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2823[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2824[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2825[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2826[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2827[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2828[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2829[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2830[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2831[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2832[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2833[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2834[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2835[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2836[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2837[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2838[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2839[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2840[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2841[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2842[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2843[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2844[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2845[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2846[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2847[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2848[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2849[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2850[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2851[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2852[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2853[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2854[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2855[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2856[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2857[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2858[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2859[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2860[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2861[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2862[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2863[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2864[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2865[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2866[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2867[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2868[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2869[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2870[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2871[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2872[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2873[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2874[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2875[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2876[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2877[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2878[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2879[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2880[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2881[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2882[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2883[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2884[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2885[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2886[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2887[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2888[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2889[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2890[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2891[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2892[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2893[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2894[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2895[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2896[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2897[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2898[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2899[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2900[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2901[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2902[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2903[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2904[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2905[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2906[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2907[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2908[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2909[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2910[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2911[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2912[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2913[info] - Applicative[Task.Par].applicative.ap consistent with product + map

2914[info] - Applicative[Task.Par].applicative.applicative homomorphism

2915[info] - Applicative[Task.Par].applicative.applicative identity

2916[info] - Applicative[Task.Par].applicative.applicative interchange

2917[info] - Applicative[Task.Par].applicative.applicative map

2918[info] - Applicative[Task.Par].applicative.applicative unit

2919[info] - Applicative[Task.Par].applicative.apply composition

2920[info] - Applicative[Task.Par].applicative.covariant composition

2921[info] - Applicative[Task.Par].applicative.covariant identity

2922[info] - Applicative[Task.Par].applicative.invariant composition

2923[info] - Applicative[Task.Par].applicative.invariant identity

2924[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

2925[info] - Applicative[Task.Par].applicative.map2/product-map consistency

2926[info] - Applicative[Task.Par].applicative.monoidal left identity

2927[info] - Applicative[Task.Par].applicative.monoidal right identity

2928[info] - Applicative[Task.Par].applicative.productL consistent map2

2929[info] - Applicative[Task.Par].applicative.productR consistent map2

2930[info] - Applicative[Task.Par].applicative.semigroupal associativity

2931[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2932[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2933[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2934[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2935[info] - Monoid[IO[Throwable, Int]].monoid.associative

2936[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2937[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2938[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2939[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2940[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2941[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2942[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2943[info] - Monoid[IO[Throwable, Int]].monoid.is id

2944[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2945[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2946[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2947[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2948[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2949[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2950[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2951[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2952[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2953[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2954[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2955[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2956[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2958************************

2959Build summary:

2960[{

2961 "module": "monix-bio",

2962 "compile": {"status": "ok", "tookMs": 18485, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2963 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2964 "test-compile": {"status": "ok", "tookMs": 38261, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2965 "test": {"status": "ok", "tookMs": 32004, "passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607, "byFramework": [{"framework": "unknown", "stats": {"passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607}}]},

2966 "publish": {"status": "skipped", "tookMs": 0},

2967 "metadata": {

2968 "crossScalaVersions": ["2.12.13", "2.13.5", "3.0.0"]

2969}

2970}]

2971************************

2972[success] Total time: 92 s (0:01:32.0), completed Jan 8, 2026, 1:45:09 AM

2973[0JChecking patch project/plugins.sbt...

2974Checking patch project/build.properties...

2975Checking patch build.sbt...

2976Applied patch project/plugins.sbt cleanly.

2977Applied patch project/build.properties cleanly.

2978Applied patch build.sbt cleanly.