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.1-RC1

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.1-RC1

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.1-RC1

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.1-RC1

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.1-RC1"

60"++3.8.1-RC1 -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.1-RC1 """{"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 8.823s.

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.1-RC1

195OpenCB::Changing crossVersion 3.0.0 -> 3.8.1-RC1 in tracingTests/crossScalaVersions

196OpenCB::Changing crossVersion 3.0.0 -> 3.8.1-RC1 in coreJVM/crossScalaVersions

197OpenCB::Changing crossVersion 3.0.0 -> 3.8.1-RC1 in benchmarks/crossScalaVersions

198OpenCB::Changing crossVersion 3.0.0 -> 3.8.1-RC1 in coreJS/crossScalaVersions

199OpenCB::Changing crossVersion 3.0.0 -> 3.8.1-RC1 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.1-RC1 on 5 projects.

202[info] Switching Scala version on:

203[info] benchmarks (2.12.13, 2.13.5, 3.8.1-RC1)

204[info] tracingTests (2.12.13, 2.13.5, 3.8.1-RC1)

205[info] coreJS (2.12.13, 2.13.5, 3.8.1-RC1)

206[info] coreJVM (2.12.13, 2.13.5, 3.8.1-RC1)

207[info] * monix-bio (2.12.13, 2.13.5, 3.8.1-RC1)

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 13, 2026, 7:30:54 PM

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.1-RC1/classes ...

246[info] done compiling

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

250[info] done compiling

251[info] monix.bio.IODoOnFinishSuite

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

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

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

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

256[info] monix.bio.TaskConnectionSuite

257[info] - initial push

258[info] - cancels Task after being canceled

259[info] - cancels Cancelable after being canceled

260[info] - cancels CancelableF after being canceled

261[info] - push two, pop one

262[info] - cancel the second time is a no-op

263[info] - push two, pop two

264[info] - push(Cancelable)

265[info] - push(Cancelable) then pop

266[info] - push(CancelToken)

267[info] - push(CancelToken) then pop

268[info] - pop when self is empty

269[info] - pop when self is canceled

270[info] - cancel mixture

271[info] - cancel mixture after being cancelled

272[info] - tryReactive

273[info] - toCancelable

274[info] - uncancelable ref is shared

275[info] - uncancelable ops

276[info] - throwing error in Task on cancel all

277[info] - throwing multiple errors in Tasks on cancel all

278[info] - throwing error in Task after cancel

279[info] - throwing error in Cancelable on cancel all

280[info] - throwing multiple errors in Cancelables on cancel all

281[info] - throwing error in Cancelable after cancel

282[info] monix.bio.TaskTerminationSuite

283[info] - IO#redeemCause should mirror source on success

284[info] - IO#redeemCause should recover typed error

285[info] - IO#redeemCause should recover unexpected error

286[info] - IO#redeemCause should protect against user code

287[info] - IO#redeemCauseWith derives flatMap

288[info] - IO#redeemCauseWith should mirror source on success

289[info] - IO#redeemCauseWith should recover typed error

290[info] - IO#redeemCauseWith should recover unexpected error

291[info] - IO#redeemCauseWith should protect against user code

292[info] monix.bio.TaskConnectionRefSuite

293[info] - assign and cancel a Cancelable

294[info] - assign and cancel a CancelableF

295[info] - assign and cancel a CancelToken[Task]

296[info] - cancel a Cancelable on single assignment

297[info] - cancel a CancelableF on single assignment

298[info] - cancel a Task on single assignment

299[info] monix.bio.IOFromFutureEitherSuite

300[info] - IO.fromFutureEither should return success channel for Right

301[info] - IO.fromFutureEither should return checked failure channel for Left

302[info] - IO.fromFutureEither should return unchecked failure channel for a failed Future

303[info] - IO.fromFutureEither(cancelable) should work for Right synchronous results onSuccess

304[info] - IO.fromFutureEither(cancelable) should work for Left synchronous results onSuccess

305[info] - IO.fromFutureEither(cancelable) should work for synchronous results onFailure

306[info] - IO.fromFutureEither(cancelable) should be short-circuited for Right onSuccess

307[info] - IO.fromFutureEither(cancelable) should be short-circuited for Left onSuccess

308[info] - IO.fromFutureEither(cancelable) should be short-circuited onError

309[info] - IO.fromFutureEither(cancelable) should work onSuccess

310[info] - IO.fromFutureEither(cancelable) should work onError

311[info] - IO.fromFutureEither(cancelable) should be cancelable

312[info] - IO.fromFutureEither should be stack safe

313[info] monix.bio.TaskTraverseSuite

314[info] - IO.traverse should not execute in parallel

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

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

317[info] - IO.traverse should be canceled

318[info] monix.bio.TaskCancellationSuite

319[info] - cancellation works for async actions

320[info] - cancellation works for autoCancelableRunLoops

321[info] - task.start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> UIO.never

322[info] - uncancelable works for async actions

323[info] - uncancelable works for autoCancelableRunLoops

324[info] - uncancelable is stack safe in flatMap loop, take 1

325[info] - uncancelable is stack safe in flatMap loop, take 2

326[info] - fa.onCancelRaiseError <-> fa

327[info] - fa.onCancelRaiseError(e).start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> raiseError(e)

328[info] - cancelBoundary happy path

329[info] - cancelBoundary execution is immediate

330[info] - cancelBoundary is stack safe

331[info] - cancelBoundary cancels

332[info] - onCancelRaiseError resets cancellation flag

333[info] - errors raised after cancel get reported

334[info] - terminal errors raised after cancel get reported

335[info] - onCancelRaiseError is stack safe in flatMap loop, take 1

336[info] - onCancelRaiseError is stack safe in flatMap loop, take 2

337[info] - local.write.uncancelable works

338[info] - local.write.onCancelRaiseError works

339[info] monix.bio.TaskVoidSuite

340[info] - IO.void should work

341[info] monix.bio.FiberDoctest

342[info] - Fiber.scala:22: Fiber

343[info] monix.bio.TaskMiscSuite

344[info] - IO.attempt should succeed

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

346[info] - IO.mapError should map error

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

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

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

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

351[info] - IO.failed should expose error

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

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

354[info] - IO.forever

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

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

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

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

359[info] - IO.toReactivePublisher should be cancelable

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

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

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

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

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

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

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

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

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

369[info] monix.bio.TaskLikeConversionsJava8Suite

370[info] - IO.from converts successful CompletableFuture

371[info] - IO.from converts failed CompletableFuture

372[info] - IO.from preserves cancellability of CompletableFuture

373[info] monix.bio.TaskAsyncSuite

374[info] - IO.never should never complete

375[info] - IO.async should execute

376[info] - IO.async should signal errors in register

377[info] - IO.async should be stack safe

378[info] - IO.async works for immediate successful value

379[info] - IO.async works for immediate error

380[info] - IO.async works for immediate terminate error

381[info] - IO.async is memory safe in flatMap loops

382[info] - IO.async0 works for immediate successful value

383[info] - IO.async0 works for async successful value

384[info] - IO.async0 works for async error

385[info] - IO.async0 works for async terminate error

386[info] - IO.async0 is memory safe in synchronous flatMap loops

387[info] - IO.async0 is memory safe in async flatMap loops

388value1: 0

389value2: 100

390value3: 400

391value4: 100

392value5: 0

393[info] monix.bio.IOLocalDoctest

394[info] - IOLocal.scala:23: IOLocal

395[info] - IOLocal.scala:124: bind

396[info] - IOLocal.scala:148: bindL

397[info] - IOLocal.scala:179: bindClear

398[info] monix.bio.TaskDeferActionSuite

399[info] - IO.deferAction works

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

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

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

403[info] - IO.deferAction is stack safe

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

405[info] monix.bio.TaskOptionsSuite

406[info] - change options with future

407[info] - change options with callback

408[info] monix.bio.TaskDelaySuite

409[info] - IO#delayExecution should work

410[info] - IO#delayExecution is stack safe, test 1

411[info] - IO#delayExecution is stack safe, test 2

412[info] - IO#delayExecution is cancelable

413[info] - IO#delayResult should work

414[info] - IO#delayResult is stack safe, test 1

415[info] - IO#delayResult is stack safe, test 2

416[info] - IO#delayResult is cancelable

417[info] - IO#delayResult should not delay in case of error

418[info] - IO#delayResult should not delay in case of terminal error

419[info] monix.bio.TaskToFutureSuite

420[info] - Task.fromFuture for already completed references

421[info] - Task.deferFuture for already completed references

422[info] - Task.deferFutureAction for already completed references

423[info] - Task.fromFuture(error) for already completed references

424[info] - Task.deferFuture(error) for already completed references

425[info] - Task.deferFutureAction(typed) for already completed references

426[info] - Task.fromFuture for completed reference is stack safe (flatMap)

427[info] - Task.deferFuture for completed reference is stack safe (flatMap)

428[info] - Task.deferFutureAction for completed reference is stack safe (flatMap)

429[info] - Task.fromFuture async result

430[info] - Task.fromFuture(error) async result

431[info] - Task.deferFuture async result

432[info] - Task.deferFuture(error) async result

433[info] - Task.deferFuture(throw error) async result

434[info] - Task.deferFutureAction async result

435[info] - Task.deferFutureAction(error) async result

436[info] - Task.deferFutureAction(throw error) async result

437[info] - Task.fromFuture(cancelable)

438[info] - Task.fromFuture(cancelable) is cancelable

439[info] - Task.deferFuture(cancelable)

440[info] - Task.deferFuture(cancelable) is cancelable

441[info] - Task.deferFutureAction(cancelable)

442[info] - Task.deferFutureAction(cancelable) is cancelable

443[info] monix.bio.IOStartAndForgetSuite

444[info] - IO#startAndForget triggers execution in background thread

445[info] - IO#startAndForget does not affect execution of main thread with raised errors

446[info] - IO#startAndForget triggers fatal errors in background thread

447[info] - IO#startAndForget is stack safe

448[info] monix.bio.TaskNowSuite

449[info] - IO.now should work synchronously

450[info] - IO.now.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

451[info] - IO.now.runAsync(callback) should work synchronously

452[info] - IO.now.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

453[info] - IO.raiseError should work synchronously

454[info] - IO.terminate should work synchronously

455[info] - IO.raiseError.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

456[info] - IO.raiseError.runAsync(callback) should work synchronously

457[info] - IO.raiseError.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

458[info] - IO.now.map should work

459[info] - IO.raiseError.map should be the same as IO.raiseError

460[info] - IO.raiseError.flatMap should be the same as IO.flatMap

461[info] - IO.raiseError.flatMap should be protected

462[info] - IO.now.flatMap should protect against user code

463[info] - IO.now.flatMap should be tail recursive

464[info] - IO.now should not be cancelable

465[info] - IO.raiseError should not be cancelable

466[info] - IO.terminate should not be cancelable

467[info] - IO.now.runSyncStep

468[info] - IO.raiseError.runSyncStep

469[info] monix.bio.TaskCallbackSuite

470[info] - onValue should invoke onSuccess

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

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

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

474[info] - contramap should pipe onError

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

476[info] - BiCallback.fromPromise (success)

477[info] - BiCallback.fromPromise (failure)

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

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

480[info] - BiCallback.empty reports errors

481[info] - BiCallback.empty reports terminal errors

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

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

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

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

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

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

488[info] - fromAttempt success

489[info] - fromAttempt error

490[info] - fromAttempt termination

491[info] monix.bio.TaskErrorSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

514[info] - IO.onErrorRestart should retry onError

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

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

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

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

519[info] - IO.onErrorRestartIf should retry onError

520[info] - IO.onErrorRestartIf should emit onError

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

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

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

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

525[info] - IO#onErrorRecoverWith should recover

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

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

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

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

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

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

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

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

538[info] - Task.onErrorRestartLoop works for success

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

540[info] - Task.onErrorRestartLoop can rethrow

541[info] monix.bio.TaskFlipSuite

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

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

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

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

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

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

548[info] monix.bio.TaskRejectedExecutionSuite

550[info] monix.bio.TaskConversionsKSuite

551[info] - Task.liftTo[CIO]

552[info] - Task.liftToAsync[IO]

553[info] - Task.liftToConcurrent[IO]

554[info] - Task.liftFrom[IO]

555[info] - Task.liftFromEffect[IO]

556[info] - Task.liftFromConcurrentEffect[IO]

557[info] monix.bio.TaskFromFutureSuite

558[info] - Task.fromFuture should be faster for completed futures, success

559[info] - Task.fromFuture should be faster for completed futures, failure

560[info] - Task.fromFuture should work onSuccess

561[info] - Task.fromFuture should work onError

562[info] - Task.fromFuture should be short-circuited onSuccess

563[info] - Task.fromFuture should be short-circuited onError

564[info] - Task.fromFuture(cancelable) should work for synchronous results onSuccess

565[info] - Task.fromFuture(cancelable) should work for synchronous results onFailure

566[info] - Task.fromFuture(cancelable) should be short-circuited onSuccess

567[info] - Task.fromFuture(cancelable) should be short-circuited onError

568[info] - Task.fromFuture(cancelable) should work onSuccess

569[info] - Task.fromFuture(cancelable) should work onError

570[info] - Task.fromFuture(cancelable) should be cancelable

571[info] - Task.fromFuture should be stack safe

572[info] - Task.now.fromFuture should be stack safe

573[info] monix.bio.TaskParSequenceUnorderedSuite

574[info] - IO.parSequenceUnordered should execute in parallel

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

576[info] - IO.parSequenceUnordered should onTerminate if one of the tasks terminates in a fatal error

577[info] - IO.parSequenceUnordered should be canceled

578[info] - IO.parSequenceUnordered should run over an iterable

579[info] - IO.parSequenceUnordered should be stack-safe on handling many tasks

580[info] - IO.parSequenceUnordered should be stack safe on success

581[info] - IO.parSequenceUnordered should log errors if multiple errors happen

582[info] - IO.parSequenceUnordered should log terminal errors if multiple errors happen

583[info] - IO.parSequenceUnordered runAsync multiple times

584[info] monix.bio.TaskAsyncAutoShiftJVMSuite

585[info] - Task.fromFuture(async) should shift back to the main scheduler

586[info] - Task.fromFuture(completed) should not shift to the main scheduler

587[info] - Task.fromFuture(async error) should shift back to the main scheduler

588[info] - Task.fromFuture(completed error) should not shift to the main scheduler

589[info] - Task.deferFuture(async) should shift back to the main scheduler

590[info] - Task.deferFuture(completed) should not shift to the main scheduler

591[info] - Task.deferFuture(async error) should shift back to the main scheduler

592[info] - Task.deferFuture(completed error) should not shift to the main scheduler

593[info] - Task.deferFutureAction(async) should shift back to the main scheduler

594[info] - Task.deferFutureAction(completed) should not shift to the main scheduler

595[info] - Task.deferFutureAction(async error) should shift back to the main scheduler

596[info] - Task.deferFutureAction(completed error) should not shift to the main scheduler

597[info] - Task.fromFuture(async cancelable) should shift back to the main scheduler

598[info] - Task.fromFuture(completed cancelable) should not shift to the main scheduler

599[info] - Task.fromFuture(async error cancelable) should shift back to the main scheduler

600[info] - Task.fromFuture(completed error cancelable) should not shift to the main scheduler

601[info] - Task.deferFuture(async cancelable) should shift back to the main scheduler

602[info] - Task.deferFuture(completed cancelable) should not shift to the main scheduler

603[info] - Task.deferFuture(async error cancelable) should shift back to the main scheduler

604[info] - Task.deferFuture(completed error cancelable) should not shift to the main scheduler

605[info] - Task.deferFutureAction(async cancelable) should shift back to the main scheduler

606[info] - Task.deferFutureAction(completed cancelable) should not shift to the main scheduler

607[info] - Task.deferFutureAction(async error cancelable) should shift back to the main scheduler

608[info] - Task.deferFutureAction(completed error cancelable) should not shift to the main scheduler

609[info] - Task.async(register) should shift back if register forks

610[info] - Task.async(register) should not shift back if register does not fork

611[info] - Task.async(register typed) should shift back if register forks

612[info] - Task.async(register error) should not shift back if register does not fork

613[info] - Task.async0(register) should shift back if register forks

614[info] - Task.async0(register) should not shift back if register does not fork

615[info] - Task.async0(register error) should shift back if register forks

616[info] - Task.async0(register error) should not shift back if register does not fork

617[info] - Task.cancelable(register) should shift back if register forks

618[info] - Task.cancelable(register) should not shift back if register does not fork

619[info] - Task.cancelable(register error) should shift back if register forks

620[info] - Task.cancelable(register error) should not shift back if register does not fork

621[info] - Task.cancelable0(register) should shift back if register forks

622[info] - Task.cancelable0(register) should not shift back if register does not fork

623[info] - Task.cancelable0(register error) should shift back if register forks

624[info] - Task.cancelable0(register error) should not shift back if register does not fork

625[info] - Task.create(register) should shift back if register forks

626[info] - Task.create(register) should not shift back if register does not fork

627[info] - Task.create(register error) should shift back if register forks

628[info] - Task.create(register error) should not shift back if register does not fork

629[info] - Task.asyncF(register) should shift back if register forks

630[info] - Task.asyncF(register) should not shift back if register does not fork

631[info] - Task.asyncF(register error) should shift back if register forks

632[info] - Task.asyncF(register error) should not shift back if register does not fork

633[info] monix.bio.TaskExecuteWithOptionsSuite

634[info] - executeWithOptions works

635[info] - local.write.executeWithOptions

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

637[info] monix.bio.TaskBracketSuite

638[info] - equivalence with onErrorHandleWith

639[info] - equivalence with flatMap + redeemWith

640[info] - equivalence with flatMap + redeemCauseWith

641[info] - use is protected against user error

642[info] - release is evaluated on success

643[info] - release is evaluated on error

644[info] - release is evaluated on terminal error

645[info] - release is evaluated on cancel

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

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

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

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

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

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

652[info] - use is not evaluated on cancel

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

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

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

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

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

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

659[info] - Multiple cancel should not hang

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

661[info] - bracket can be canceled while terminating

662[info] monix.bio.TaskParTraverseSuite

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

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

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

666[info] - IO.parTraverse should be canceled

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

668[info] - IO.parTraverse runAsync multiple times

670[info] monix.bio.TaskGuaranteeSuite

671[info] - finalizer is evaluated on success

672[info] - finalizer is evaluated on error

673[info] - finalizer is evaluated on terminal error

674[info] - if finalizer throws, report finalizer error and signal use error

675[info] - finalizer is evaluated on cancelation (1)

676[info] - finalizer is evaluated on cancellation (2)

677[info] - stack-safety (1)

678[info] - stack-safety (2)

679[info] - stack-safety (3)

680[info] monix.bio.TypeClassLawsForTaskSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

958[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite

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

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

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

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

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

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

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

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

967[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

968[info] - Concurrent[Task].async.ap consistent with product + map

969[info] - Concurrent[Task].async.applicative homomorphism

970[info] - Concurrent[Task].async.applicative identity

971[info] - Concurrent[Task].async.applicative interchange

972[info] - Concurrent[Task].async.applicative map

973[info] - Concurrent[Task].async.applicative unit

974[info] - Concurrent[Task].async.applicativeError adaptError pure

975[info] - Concurrent[Task].async.applicativeError adaptError raise

976[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

977[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

978[info] - Concurrent[Task].async.applicativeError handle

979[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

980[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

981[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

982[info] - Concurrent[Task].async.applicativeError handleError pure

983[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

984[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

985[info] - Concurrent[Task].async.applicativeError handleWith

986[info] - Concurrent[Task].async.applicativeError onError pure

987[info] - Concurrent[Task].async.applicativeError onError raise

988[info] - Concurrent[Task].async.applicativeError pure attempt

989[info] - Concurrent[Task].async.applicativeError raiseError attempt

990[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

991[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

992[info] - Concurrent[Task].async.apply composition

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

994[info] - Concurrent[Task].async.async left is raiseError

995[info] - Concurrent[Task].async.async right is pure

996[info] - Concurrent[Task].async.bind suspends evaluation

997[info] - Concurrent[Task].async.bracket is derived from bracketCase

998[info] - Concurrent[Task].async.bracket release is called on Completed or Error

999[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

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

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

1002[info] - Concurrent[Task].async.covariant composition

1003[info] - Concurrent[Task].async.covariant identity

1004[info] - Concurrent[Task].async.delay constant is pure

1005[info] - Concurrent[Task].async.flatMap associativity

1006[info] - Concurrent[Task].async.flatMap consistent apply

1007[info] - Concurrent[Task].async.flatMap from tailRecM consistency

1008[info] - Concurrent[Task].async.guarantee is derived from bracket

1009[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

1010[info] - Concurrent[Task].async.invariant composition

1011[info] - Concurrent[Task].async.invariant identity

1012[info] - Concurrent[Task].async.map flatMap coherence

1013[info] - Concurrent[Task].async.map suspends evaluation

1014[info] - Concurrent[Task].async.map2/map2Eval consistency

1015[info] - Concurrent[Task].async.map2/product-map consistency

1016[info] - Concurrent[Task].async.monad left identity

1017[info] - Concurrent[Task].async.monad right identity

1018[info] - Concurrent[Task].async.monadError ensure consistency

1019[info] - Concurrent[Task].async.monadError ensureOr consistency

1020[info] - Concurrent[Task].async.monadError left zero

1021[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

1022[info] - Concurrent[Task].async.monadError rethrow attempt

1023[info] - Concurrent[Task].async.monoidal left identity

1024[info] - Concurrent[Task].async.monoidal right identity

1025[info] - Concurrent[Task].async.mproduct consistent flatMap

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

1027[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

1028[info] - Concurrent[Task].async.productL consistent map2

1029[info] - Concurrent[Task].async.productR consistent map2

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

1031[info] - Concurrent[Task].async.propagate errors through bind (suspend)

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

1033[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

1034[info] - Concurrent[Task].async.repeated sync evaluation not memoized

1035[info] - Concurrent[Task].async.semigroupal associativity

1036[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

1037[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

1038[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

1039[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

1040[info] - Concurrent[Task].async.stack-safe on left-associated binds

1041[info] - Concurrent[Task].async.stack-safe on repeated attempts

1042[info] - Concurrent[Task].async.stack-safe on repeated maps

1043[info] - Concurrent[Task].async.stack-safe on right-associated binds

1044[info] - Concurrent[Task].async.suspend constant is pure join

1045[info] - Concurrent[Task].async.tailRecM consistent flatMap

1046[info] - Concurrent[Task].async.tailRecM stack safety

1047[info] - Concurrent[Task].async.throw in delay is raiseError

1048[info] - Concurrent[Task].async.throw in suspend is raiseError

1049[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

1050[info] - Concurrent[Task].async.unsequenced delay is no-op

1051[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

1052[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

1053[info] - ConcurrentEffect[Task].effect.applicative homomorphism

1054[info] - ConcurrentEffect[Task].effect.applicative identity

1055[info] - ConcurrentEffect[Task].effect.applicative interchange

1056[info] - ConcurrentEffect[Task].effect.applicative map

1057[info] - ConcurrentEffect[Task].effect.applicative unit

1058[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

1059[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

1060[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

1061[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

1062[info] - ConcurrentEffect[Task].effect.applicativeError handle

1063[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

1064[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

1065[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

1066[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

1067[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

1068[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

1069[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

1070[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

1071[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

1072[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

1073[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

1074[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

1075[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

1076[info] - ConcurrentEffect[Task].effect.apply composition

1077[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

1078[info] - ConcurrentEffect[Task].effect.async left is raiseError

1079[info] - ConcurrentEffect[Task].effect.async right is pure

1080[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

1081[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

1082[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

1083[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

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

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

1086[info] - ConcurrentEffect[Task].effect.covariant composition

1087[info] - ConcurrentEffect[Task].effect.covariant identity

1088[info] - ConcurrentEffect[Task].effect.delay constant is pure

1089[info] - ConcurrentEffect[Task].effect.flatMap associativity

1090[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

1091[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

1092[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

1093[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

1094[info] - ConcurrentEffect[Task].effect.invariant composition

1095[info] - ConcurrentEffect[Task].effect.invariant identity

1096[info] - ConcurrentEffect[Task].effect.map flatMap coherence

1097[info] - ConcurrentEffect[Task].effect.map suspends evaluation

1098[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

1099[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

1100[info] - ConcurrentEffect[Task].effect.monad left identity

1101[info] - ConcurrentEffect[Task].effect.monad right identity

1102[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

1103[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

1104[info] - ConcurrentEffect[Task].effect.monadError left zero

1105[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

1106[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

1107[info] - ConcurrentEffect[Task].effect.monoidal left identity

1108[info] - ConcurrentEffect[Task].effect.monoidal right identity

1109[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

1110[info] - ConcurrentEffect[Task].effect.never is derived from async

1111[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

1112[info] - ConcurrentEffect[Task].effect.productL consistent map2

1113[info] - ConcurrentEffect[Task].effect.productR consistent map2

1114[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

1115[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

1116[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

1117[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

1118[info] - ConcurrentEffect[Task].effect.repeated callback ignored

1119[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

1120[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

1121[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

1122[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

1123[info] - ConcurrentEffect[Task].effect.semigroupal associativity

1124[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

1125[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

1126[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

1127[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

1128[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

1129[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

1130[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

1131[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

1132[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

1133[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

1134[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

1135[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

1136[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

1137[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

1138[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

1139[info] - ConcurrentEffect[Task].effect.toIO stack safety

1140[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

1141[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1161[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1162[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1163[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1164[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1165[info] - Monoid[IO[Throwable, Int]].monoid.associative

1166[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1167[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1168[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1169[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1170[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1171[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1172[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1173[info] - Monoid[IO[Throwable, Int]].monoid.is id

1174[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1175[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1176[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1177[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1178[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1179[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1180[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1181[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1182[info] - Monoid[IO[Throwable, Int]].monoid.right identity

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

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

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

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

1187[info] monix.bio.TaskClockTimerAndContextShiftSuite

1188[info] - IO.clock is implicit

1189[info] - IO.clock.monotonic

1190[info] - IO.clock.realTime

1191[info] - IO.clock(s2).monotonic

1192[info] - IO.clock(s).realTime

1193[info] - IO.timer is implicit

1194[info] - IO.timer

1195[info] - IO.timer(s)

1196[info] - IO.timer(s).clock

1197[info] - IO.contextShift is implicit

1198[info] - IO.contextShift.shift

1199[info] - IO.contextShift.evalOn(s2)

1200[info] - IO.contextShift.evalOn(s2) failure

1201[info] - IO.contextShift.evalOn(s2) fatal failure

1202[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries

1203[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction

1204[info] - IO.contextShift(s).shift

1205[info] - IO.contextShift(s).evalOn(s2)

1206[info] - IO.contextShift(s).evalOn(s2) failure

1207[info] - IO.contextShift(s).evalOn(s2) fatal failure

1208[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries

1209[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction

1210[info] monix.bio.TaskLikeConversionsSuite

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

1212[info] - IO.from converts successful Future

1213[info] - IO.from converts failed Future

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

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

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

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

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

1219[info] - IO.from converts successful Eval

1220[info] - IO.from converts failed Eval

1221[info] - IO.from preserves Eval laziness

1222[info] - IO.from converts successful SyncIO

1223[info] - IO.from converts failed SyncIO

1224[info] - IO.from converts successful Try

1225[info] - IO.from converts failed Try

1226[info] - IO.from converts right Either

1227[info] - IO.from converts left Either

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

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

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

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

1232[info] - IO.from converts Function0

1233[info] - IO.from converts CancelablePromise

1234[info] monix.bio.TaskParSequenceSuite

1235[info] - IO.parSequence should execute in parallel for async tasks

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

1237[info] - IO.parSequence should onTerminate if one of the tasks terminates in a fatal error

1238[info] - IO.parSequence should be canceled

1239[info] - IO.parSequence should be stack safe for synchronous tasks

1240[info] - IO.parSequence runAsync multiple times

1241[info] - IO.parSequence should log errors if multiple errors happen

1242[info] - IO.parSequence should log terminal errors if multiple errors happen

1243[info] monix.bio.TaskMapBothSuite

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

1245[info] - sum two async tasks

1246[info] - sum two synchronous tasks

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

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

1249[info] - should have a stack safe cancelable

1250[info] - sum random synchronous tasks

1251[info] - sum random asynchronous tasks

1252[info] - both task can fail with error

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

1254[info] monix.bio.TaskMemoizeSuite

1255[info] - IO.memoize should work asynchronously for first subscriber

1256[info] - IO.memoize should work synchronously for next subscribers

1257[info] - IO.memoize should be stack safe

1258[info] - IO.flatMap.memoize should be stack safe, test 1

1259[info] - IO.flatMap.memoize should be stack safe, test 2

1260[info] - IO.raiseError(error).memoize should work

1261[info] - IO.terminate(error).memoize should work

1262[info] - IO.memoize.materialize

1263[info] - IO.apply(error).memoize.materialize

1264[info] - IO.eval.memoize should work for first subscriber

1265[info] - IO.eval.memoize should work synchronously for next subscribers

1266[info] - IO.eval(error).memoize should work

1267[info] - IO.eval.memoize

1268[info] - IO.eval.memoize should be stack safe

1269[info] - IO.eval.flatMap.memoize should be stack safe

1270[info] - IO.defer(evalAlways).memoize

1271[info] - IO.evalOnce.memoize should work for first subscriber

1272[info] - IO.evalOnce.memoize should work synchronously for next subscribers

1273[info] - IO.evalOnce(error).memoize should work

1274[info] - IO.evalOnce.memoize should be stack safe

1275[info] - IO.evalOnce.flatMap.memoize should be stack safe

1276[info] - IO.now.memoize should work synchronously for first subscriber

1277[info] - IO.now.memoize should work synchronously for next subscribers

1278[info] - IO.error.memoize should work

1279[info] - IO.now.memoize should be stack safe

1280[info] - IO.now.flatMap.memoize should be stack safe

1281[info] - IO.defer.memoize should be stack safe

1282[info] - IO.memoize effects, sequential

1283[info] - IO.memoize effects, parallel

1284[info] - IO.suspend.memoize effects

1285[info] - IO.suspend.flatMap.memoize effects

1286[info] - IO.memoize should make subsequent subscribers wait for the result, as future

1287[info] - IO.memoize should make subsequent subscribers wait for the result, as callback

1288[info] - Task.memoize should be synchronous for subsequent subscribers, as callback

1289[info] - IO.memoize should not be cancelable (future)

1290[info] - IO.memoize should be cancelable (callback, #1)

1291[info] - IO.memoize should be cancelable (callback, #2)

1292[info] - IO.memoize should be re-executable after cancel

1293[info] - IO.memoize should not be uninterruptible

1294[info] - IO.memoize serves error after async boundary

1295[info] - TaskRunLoop.startLightWithBiCallback for success

1296[info] - TaskRunLoop.startLightWithBiCallback for failure

1297[info] - IO.evalOnce eq IO.evalOnce.memoize

1298[info] - IO.eval.memoize eq IO.eval.memoize.memoize

1299[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoize

1300[info] - IO.now.memoize eq IO.now

1301[info] - IO.raiseError.memoize eq IO.raiseError

1302[info] - IO.terminate.memoize eq IO.raiseError

1303[info] - IO.eval.memoizeOnSuccess.memoize !== IO.eval.memoizeOnSuccess

1304[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1532[info] - Applicative[Task.Par].applicative.ap consistent with product + map

1533[info] - Applicative[Task.Par].applicative.applicative homomorphism

1534[info] - Applicative[Task.Par].applicative.applicative identity

1535[info] - Applicative[Task.Par].applicative.applicative interchange

1536[info] - Applicative[Task.Par].applicative.applicative map

1537[info] - Applicative[Task.Par].applicative.applicative unit

1538[info] - Applicative[Task.Par].applicative.apply composition

1539[info] - Applicative[Task.Par].applicative.covariant composition

1540[info] - Applicative[Task.Par].applicative.covariant identity

1541[info] - Applicative[Task.Par].applicative.invariant composition

1542[info] - Applicative[Task.Par].applicative.invariant identity

1543[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

1544[info] - Applicative[Task.Par].applicative.map2/product-map consistency

1545[info] - Applicative[Task.Par].applicative.monoidal left identity

1546[info] - Applicative[Task.Par].applicative.monoidal right identity

1547[info] - Applicative[Task.Par].applicative.productL consistent map2

1548[info] - Applicative[Task.Par].applicative.productR consistent map2

1549[info] - Applicative[Task.Par].applicative.semigroupal associativity

1550[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1551[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1552[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1553[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1554[info] - Monoid[IO[Throwable, Int]].monoid.associative

1555[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1556[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1557[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1558[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1559[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1560[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1561[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1562[info] - Monoid[IO[Throwable, Int]].monoid.is id

1563[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1564[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1565[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1566[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1567[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1568[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1569[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1570[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1571[info] - Monoid[IO[Throwable, Int]].monoid.right identity

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

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

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

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

1576[info] monix.bio.TaskEvalOnceSuite

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

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

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

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

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

1582[info] - IO.EvalOnce.runAsync override

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

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

1585[info] monix.bio.TaskEvalAsyncSuite

1586[info] - IO.evalAsync should work, on different thread

1587[info] - IO.evalAsync should protect against user code errors

1588[info] - UIO.evalAsync should protect against user code errors

1589[info] - IO.evalAsync is equivalent with IO.eval

1590[info] - IO.evalAsync is equivalent with IO.evalOnce on first run

1591[info] - IO.evalAsync.flatMap should protect against user code

1592[info] - IO.evalAsync should be tail recursive

1593[info] - IO.evalAsync.flatten is equivalent with flatMap

1594[info] - IO.evalAsync.coeval

1595[info] monix.bio.TaskToStringSuite

1596[info] - IO.Now

1597[info] - IO.Error

1598[info] - IO.Termination

1599[info] - IO.Eval

1600[info] - IO.EvalTotal

1601[info] - IO.Async

1602[info] - IO.FlatMap

1603[info] - IO.Suspend

1604[info] - IO.SuspendTotal

1605[info] - IO.Map

1606[info] monix.bio.TaskConnectionCompositeSuite

1607[info] - cancels Cancelable references

1608[info] - cancels Cancelable references after cancel on assignment

1609[info] - cancels Task references

1610[info] - cancels Task references after cancel on assignment

1611[info] - cancels CancelableF references

1612[info] - cancels CancelableF references after cancel on assignment

1613[info] - addAll

1614[info] - remove Task

1615[info] - remove Cancelable

1616[info] - remove CancelableF

1617[info] monix.bio.TaskBlockingSuite

1618[info] - blocking on future should work

1619[info] - blocking on async

1620[info] - blocking on async.flatMap

1621[info] - blocking with Termination result

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

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

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

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

1626[info] - blocking on memoize

1628[info] - IO.attempt.runSyncUnsafe works

1629[info] monix.bio.IOLocalSuite

1630[info] - IOLocal.apply

1631[info] - IOLocal.wrap

1632[info] - IOLocal!.bind

1633[info] - IOLocal!.bindL

1634[info] - IOLocal!.bindClear

1635[info] - IOLocal canceled

1636[info] - IOLocal!.local

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

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

1639[info] - IOLocal should work with bracket

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

1641[info] - IOLocal interop with future via deferFutureAction

1642[info] - IOLocal.bind scoping works

1643[info] - IOLocal.bind actually isolates reads

1644[info] - IOLocal.isolate with ConcurrentChannel

1645[info] monix.bio.TaskCallbackSafetySuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1663[info] monix.bio.TaskConversionsSuite

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

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

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

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

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

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

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

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

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

1673[info] - IO.toAsync converts successful tasks

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

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

1676[info] - IO.toConcurrent converts successful tasks

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1702[info] - IO.fromReactivePublisher is cancelable

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

1704[info] monix.bio.BIOAppSuite

1705[info] - run works

1706[info] - options are configurable

1707[info] - ConcurrentEffect[Task]

1708[info] monix.bio.TaskExecuteWithModelSuite

1709[info] - executeWithModel works

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

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

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

1713[info] monix.bio.TaskParTraverseUnorderedSuite

1714[info] - IO.parTraverseUnordered should execute in parallel

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

1716[info] - IO.parTraverseUnordered should be canceled

1717[info] - IO.parTraverseUnordered should run over an iterable

1718[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks

1719[info] - IO.parTraverseUnordered should be stack safe on success

1720[info] - IO.parTraverseUnordered should log errors if multiple errors happen

1721[info] - IO.parTraverseUnordered runAsync multiple times

1723[info] monix.bio.TaskExecuteAsyncSuite

1724[info] - IO.now.executeAsync should execute async

1725[info] - IO.now.executeOn should execute async if forceAsync = true

1726[info] - IO.now.executeOn should not execute async if forceAsync = false

1727[info] - IO.create.executeOn should execute async

1728[info] - executeAsync should be stack safe, test 1

1729[info] - IO.executeOn should be stack safe, test 2

1730[info] - executeAsync should be stack safe, test 3

1731[info] monix.bio.TaskTimedSuite

1732[info] - measure tasks with no errors

1733[info] - not measure tasks with typed errors

1734[info] - not measure tasks with terminal errors

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

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

1737[info] - stack safety

1738[info] monix.bio.IOLikeDoctest

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

1740[info] monix.bio.IOLocalJVMSuite

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

1742[info] - locals get transported with executeWithModel

1743[info] - locals get transported with executeWithOptions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1762[info] monix.bio.TaskEvalAlwaysSuite

1763[info] - IO.eval should work synchronously

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

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

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

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

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

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

1770[info] - IO.eval.coeval

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

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

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

1774Hello World!

1775Cancelling!

1776Received: $value

1777Hello!

1778Hello!

1779Success: 42

1780[info] monix.bio.IODoctest

1781[info] - IO.scala:52: IO

1782[info] - IO.scala:474: runToFuture

1783[info] - IO.scala:541: runToFutureOpt

1784[info] - IO.scala:586: runAsync

1785[info] - IO.scala:661: runAsyncOpt

1786[info] - IO.scala:716: runAsyncF

1787[info] - IO.scala:821: runAsyncAndForget

1788[info] - IO.scala:874: runAsyncUncancelable

1789[info] - IO.scala:947: runSyncStep

1790[info] - IO.scala:1011: runSyncUnsafe

1791[info] - IO.scala:1116: memoize

1792[info] - IO.scala:1155: memoizeOnSuccess

1793[info] - IO.scala:1213: >>

1794[info] - IO.scala:1226: *>

1795[info] - IO.scala:1242: <*

1796[info] - IO.scala:1257: asyncBoundary

1797[info] - IO.scala:1306: asyncBoundary

1798[info] - IO.scala:1337: bracket

1799[info] - IO.scala:1525: delayExecution

1800[info] - IO.scala:1554: delayResult

1801[info] - IO.scala:1595: executeOn

1802[info] - IO.scala:1730: executeAsync

1803[info] - IO.scala:1756: executeWithModel

1804[info] - IO.scala:1774: executeWithOptions

1805[info] - IO.scala:1801: flip

1806[info] - IO.scala:1831: flipWith

1807[info] - IO.scala:1879: flatMapLoop

1808[info] - IO.scala:1937: loopForever

1809[info] - IO.scala:2008: onCancelRaiseError

1810[info] - IO.scala:2062: mapErrorPartialWith

1811[info] - IO.scala:2113: tapError

1812[info] - IO.scala:2147: onErrorRestartIf

1813[info] - IO.scala:2167: onErrorRestartLoop

1814[info] - IO.scala:2242: mapError

1815[info] - IO.scala:2261: mapErrorPartial

1816[info] - IO.scala:2296: start

1817[info] - IO.scala:2324: to

1818[info] - IO.scala:2366: toConcurrent

1819[info] - IO.scala:2412: toAsync

1820[info] - IO.scala:2536: uncancelable

1821[info] - IO.scala:2559: timed

1822[info] - IO.scala:2608: timeoutToL

1823[info] - IO.scala:2663: hideErrors

1824[info] - IO.scala:2684: hideErrorsWith

1825[info] - IO.scala:2740: absorb

1826[info] - IO.scala:2758: absorbWith

1827[info] - IO.scala:2782: IO

1828[info] - IO.scala:2843: apply

1829[info] - IO.scala:2905: deferAction

1830[info] - IO.scala:2932: deferFuture

1831[info] - IO.scala:2945: deferFutureAction

1832[info] - IO.scala:3082: fromConcurrentEffect

1833[info] - IO.scala:3119: fromEffect

1834[info] - IO.scala:3149: fromOption

1835[info] - IO.scala:3165: fromOption

1836[info] - IO.scala:3185: fromOptionEval

1837[info] - IO.scala:3243: async

1838[info] - IO.scala:3303: async0

1839[info] - IO.scala:3399: cancelable

1840[info] - IO.scala:3479: cancelable0

1841[info] - IO.scala:3581: cancelBoundary

1842[info] - IO.scala:3617: create

1843[info] - IO.scala:3724: race

1844[info] - IO.scala:3757: raceMany

1845[info] - IO.scala:3778: racePair

1846[info] - IO.scala:3861: sleep

1847[info] - IO.scala:3952: parSequence

1848[info] - IO.scala:4011: parSequenceN

1849[info] - IO.scala:4042: parTraverseN

1850[info] - IO.scala:4079: parSequenceUnordered

1851[info] - IO.scala:4127: mapBoth

1852[info] - IO.scala:4146: map2

1853[info] - IO.scala:4175: map3

1854[info] - IO.scala:4205: map4

1855[info] - IO.scala:4238: map5

1856[info] - IO.scala:4276: map6

1857[info] - IO.scala:4316: parMap2

1858[info] - IO.scala:4351: parMap3

1859[info] - IO.scala:4389: parMap4

1860[info] - IO.scala:4430: parMap5

1861[info] - IO.scala:4476: parMap6

1862[info] - IO.scala:4562: liftTo

1863[info] - IO.scala:4622: liftFrom

1864[info] - IO.scala:5282: catsParallel

1865[info] monix.bio.TaskBimapSuite

1866[info] - IO.bimap should map the success channel

1867[info] - IO.bimap should map the error channel

1868[info] monix.bio.TaskSequenceSuite

1869[info] - IO.sequence should not execute in parallel

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

1871[info] - IO.sequence should onTerminate if one of the tasks terminates in error

1872[info] - IO.sequence should be canceled

1873[info] monix.bio.TaskExecutionModelSuite

1874[info] - IO.now.executeWithModel(AlwaysAsyncExecution) should work

1875[info] - IO.now.runAsync (CancelableFuture) should not be async with AlwaysAsyncExecution

1876[info] - IO.eval.executeWithModel(AlwaysAsyncExecution) should work

1877[info] - IO.eval should be async with AlwaysAsyncExecution

1878[info] - IO.now.flatMap loops should work with AlwaysAsyncExecution

1879[info] - IO.eval.flatMap loops should work with AlwaysAsyncExecution

1880[info] - IO.flatMap loops should work with AlwaysAsyncExecution

1881[info] monix.bio.TaskMemoizeOnSuccessSuite

1882[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber

1883[info] - IO.memoizeOnSuccess should work synchronously for next subscribers

1884[info] - IO.memoizeOnSuccess should be stack safe

1885[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1

1886[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2

1887[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent

1888[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent

1889[info] - IO.memoizeOnSuccess.materialize

1890[info] - IO.raiseError(error).memoizeOnSuccess.materialize

1891[info] - IO.terminate(error).memoizeOnSuccess.materialize

1892[info] - IO.eval.memoizeOnSuccess should work for first subscriber

1893[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers

1894[info] - IO.eval(error).memoizeOnSuccess should not be idempotent

1895[info] - IO.eval.memoizeOnSuccess

1896[info] - IO.eval.memoizeOnSuccess should be stack safe

1897[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe

1898[info] - IO.defer(evalAlways).memoizeOnSuccess

1899[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber

1900[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers

1901[info] - IO.evalOnce(error).memoizeOnSuccess should work

1902[info] - IO.evalOnce.memoizeOnSuccess should be stack safe

1903[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe

1904[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber

1905[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers

1906[info] - IO.raiseError.memoizeOnSuccess should work

1907[info] - IO.terminate.memoizeOnSuccess should work

1908[info] - IO.now.memoizeOnSuccess should be stack safe

1909[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe

1910[info] - IO.suspend.memoizeOnSuccess should be stack safe

1911[info] - IO.memoizeOnSuccess effects, sequential

1912[info] - IO.memoizeOnSuccess effects, parallel

1913[info] - IO.suspend.memoizeOnSuccess effects

1914[info] - IO.suspend.flatMap.memoizeOnSuccess effects

1915[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future

1916[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback

1917[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback

1918[info] - IO.memoizeOnSuccess should be cancellable (future)

1919[info] - IO.memoizeOnSuccess should be cancellable (callback #1)

1920[info] - IO.memoizeOnSuccess should be cancellable (callback #2)

1921[info] - IO.memoizeOnSuccess should not be cancelable

1922[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners

1923[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess

1924[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess

1925[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess

1926[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess

1927[info] - IO.now.memoizeOnSuccess eq IO.now

1928[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError

1929[info] - IO.terminate.memoizeOnSuccess eq IO.terminate

1930[info] monix.bio.IOMapNSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1951[info] monix.bio.TaskCallbackSafetyJVMSuite

1952[info] - IO.async has a safe callback

1953[info] - IO.async0 has a safe callback

1954[info] - IO.asyncF has a safe callback

1955[info] - IO.cancelable has a safe callback

1956[info] - IO.cancelable0 has a safe callback

1957[info] monix.bio.TaskAsyncBoundarySuite

1958[info] - IO.asyncBoundary should work

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

1960[info] - IO.asyncBoundary should preserve locals

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

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

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

1964Executing...

1965Received: $str

1966Executing...

1967Executing...

1968Finished via exit code: $exitCode

1969Resources were released!

1970Executing...

1971Received: $str

1972[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite

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

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

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

1976[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1977[info] - CoflatMap[Task].coflatMap.covariant composition

1978[info] - CoflatMap[Task].coflatMap.covariant identity

1979[info] - CoflatMap[Task].coflatMap.invariant composition

1980[info] - CoflatMap[Task].coflatMap.invariant identity

1981[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1982[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1983[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1984[info] - Concurrent[Task].concurrent.ap consistent with product + map

1985[info] - Concurrent[Task].concurrent.applicative homomorphism

1986[info] - Concurrent[Task].concurrent.applicative identity

1987[info] - Concurrent[Task].concurrent.applicative interchange

1988[info] - Concurrent[Task].concurrent.applicative map

1989[info] - Concurrent[Task].concurrent.applicative unit

1990[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1991[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1992[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1993[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1994[info] - Concurrent[Task].concurrent.applicativeError handle

1995[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1996[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1997[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1998[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1999[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2000[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2001[info] - Concurrent[Task].concurrent.applicativeError handleWith

2002[info] - Concurrent[Task].concurrent.applicativeError onError pure

2003[info] - Concurrent[Task].concurrent.applicativeError onError raise

2004[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2005[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2006[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2007[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2008[info] - Concurrent[Task].concurrent.apply composition

2009[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2010[info] - Concurrent[Task].concurrent.async cancelable coherence

2011[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2012[info] - Concurrent[Task].concurrent.async left is raiseError

2013[info] - Concurrent[Task].concurrent.async right is pure

2014[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2015[info] - Concurrent[Task].concurrent.bind suspends evaluation

2016[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2017[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2018[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2019[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2020[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2021[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2022[info] - Concurrent[Task].concurrent.covariant composition

2023[info] - Concurrent[Task].concurrent.covariant identity

2024[info] - Concurrent[Task].concurrent.delay constant is pure

2025[info] - Concurrent[Task].concurrent.flatMap associativity

2026[info] - Concurrent[Task].concurrent.flatMap consistent apply

2027[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2028[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2029[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2030[info] - Concurrent[Task].concurrent.invariant composition

2031[info] - Concurrent[Task].concurrent.invariant identity

2032[info] - Concurrent[Task].concurrent.join is idempotent

2033[info] - Concurrent[Task].concurrent.map flatMap coherence

2034[info] - Concurrent[Task].concurrent.map suspends evaluation

2035[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2036[info] - Concurrent[Task].concurrent.map2/product-map consistency

2037[info] - Concurrent[Task].concurrent.monad left identity

2038[info] - Concurrent[Task].concurrent.monad right identity

2039[info] - Concurrent[Task].concurrent.monadError ensure consistency

2040[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2041[info] - Concurrent[Task].concurrent.monadError left zero

2042[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2043[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2044[info] - Concurrent[Task].concurrent.monoidal left identity

2045[info] - Concurrent[Task].concurrent.monoidal right identity

2046[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2047[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2048[info] - Concurrent[Task].concurrent.productL consistent map2

2049[info] - Concurrent[Task].concurrent.productR consistent map2

2050[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2051[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2052[info] - Concurrent[Task].concurrent.race cancels both

2053[info] - Concurrent[Task].concurrent.race cancels loser

2054[info] - Concurrent[Task].concurrent.race mirrors left winner

2055[info] - Concurrent[Task].concurrent.race mirrors right winner

2056[info] - Concurrent[Task].concurrent.racePair can join left

2057[info] - Concurrent[Task].concurrent.racePair can join right

2058[info] - Concurrent[Task].concurrent.racePair cancels both

2059[info] - Concurrent[Task].concurrent.racePair cancels loser

2060[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2061[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2062[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2063[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2064[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2065[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2066[info] - Concurrent[Task].concurrent.semigroupal associativity

2067[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2068[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2069[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2070[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2071[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2072[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2073[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2074[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2075[info] - Concurrent[Task].concurrent.start then join is identity

2076[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2077[info] - Concurrent[Task].concurrent.suspend constant is pure join

2078[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2079[info] - Concurrent[Task].concurrent.tailRecM stack safety

2080[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2081[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2082[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2083[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2084[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2085[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2086[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2087[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2088[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2089[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2090[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2091[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2092[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2093[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2094[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2095[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2096[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2097[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2098[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2099[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2100[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2101[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2102[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2103[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2104[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2105[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2106[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2107[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2108[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2109[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2110[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2111[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2112[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2113[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2114[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2115[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2116[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2117[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2118[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2119[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2120[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2121[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2122[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2123[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2124[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2125[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2126[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2127[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2128[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2129[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2130[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2131[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2132[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2133[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2134[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2135[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2136[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2137[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2138[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2139[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2140[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2141[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2142[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2143[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2144[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2145[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2146[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2147[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2148[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2149[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2150[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2151[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2152[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2153[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2154[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2155[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2156[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2157[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2158[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2159[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2160[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2161[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2162[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2163[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2164[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2165[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2166[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2167[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2168[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2169[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2170[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2171[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2172[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2173[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2174[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2175[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2176[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2177[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2178[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2179[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2180[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2181[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2182[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2183[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2184[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2185[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2186[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2187[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2188[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2189[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2190[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2191[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2192[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2193[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2194[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2195[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2196[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2197[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2198[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2199[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2200[info] - Applicative[Task.Par].applicative.ap consistent with product + map

2201[info] - Applicative[Task.Par].applicative.applicative homomorphism

2202[info] - Applicative[Task.Par].applicative.applicative identity

2203[info] - Applicative[Task.Par].applicative.applicative interchange

2204[info] - Applicative[Task.Par].applicative.applicative map

2205[info] - Applicative[Task.Par].applicative.applicative unit

2206[info] - Applicative[Task.Par].applicative.apply composition

2207[info] - Applicative[Task.Par].applicative.covariant composition

2208[info] - Applicative[Task.Par].applicative.covariant identity

2209[info] - Applicative[Task.Par].applicative.invariant composition

2210[info] - Applicative[Task.Par].applicative.invariant identity

2211[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

2212[info] - Applicative[Task.Par].applicative.map2/product-map consistency

2213[info] - Applicative[Task.Par].applicative.monoidal left identity

2214[info] - Applicative[Task.Par].applicative.monoidal right identity

2215[info] - Applicative[Task.Par].applicative.productL consistent map2

2216[info] - Applicative[Task.Par].applicative.productR consistent map2

2217[info] - Applicative[Task.Par].applicative.semigroupal associativity

2218[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2219[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2220[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2221[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2222[info] - Monoid[IO[Throwable, Int]].monoid.associative

2223[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2224[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2225[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2226[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2227[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2228[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2229[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2230[info] - Monoid[IO[Throwable, Int]].monoid.is id

2231[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2232[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2233[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2234[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2235[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2236[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2237[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2238[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2239[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2240[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2241[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2242[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2243[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2244[info] monix.bio.TaskExecuteOnSuite

2245[info] - executeOn(forceAsync = false)

2246[info] - executeOn(forceAsync = true)

2247[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1

2248[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2

2249[info] - local.write.executeOn(forceAsync = false) works

2250[info] - local.write.executeOn(forceAsync = true) works

2251[info] monix.bio.TaskRaceSuite

2252[info] - IO.raceMany returns fastest success

2253[info] - IO.raceMany returns fastest typed error

2254[info] - IO.raceMany returns fastest terminal error

2255[info] - IO.raceMany returns success that is faster than typed error

2256[info] - IO.raceMany returns success that is faster than terminal error

2257[info] - IO.raceMany returns typed error that is faster than success

2258[info] - IO.raceMany returns typed error that is faster than fatal error

2259[info] - IO.raceMany returns fatal error that is faster than success

2260[info] - IO.raceMany returns fatal error that is faster than typed error

2261[info] - IO.raceMany should allow cancelling all tasks

2262[info] - IO.raceMany should be stack safe for sync values

2263[info] - IO.raceMany should be stack safe for async values

2264[info] - IO.raceMany has a stack safe cancelable

2265[info] - IO#timeout should timeout

2266[info] - IO#timeout should mirror the source in case of success

2267[info] - IO#timeout should mirror the source in case of error

2268[info] - IO#timeout should mirror the source in case of terminal error

2269[info] - IO#timeout should cancel both the source and the timer

2270[info] - IO#timeout with backup should timeout

2271[info] - IO#timeout with backup should timeout with error

2272[info] - IO#timeout with backup should mirror the source in case of success

2273[info] - IO#timeout with backup should mirror the source in case of error

2274[info] - IO#timeout should cancel both the source and the timer

2275[info] - IO#timeout should cancel the backup

2276[info] - IO#timeout should not return the source after timeout

2277[info] - IO#timeout should cancel the source after timeout

2278[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization

2279[info] - IO#timeoutL should evaluate as specified: lazy, with memoization

2280[info] - IO#timeoutL considers time taken to evaluate the duration task

2281[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed

2282[info] - IO.racePair(a,b) should work if a completes first

2283[info] - IO.racePair(a,b) should cancel both

2284[info] - IO.racePair(A,B) should not cancel B if A completes first

2285[info] - IO.racePair(A,B) should not cancel A if B completes first

2286[info] - IO.racePair(A,B) should end both in error if A completes first in error

2287[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error

2288[info] - IO.racePair(A,B) should end both in error if B completes first in error

2289[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error

2290[info] - IO.racePair(A,B) should work if A completes second in error

2291[info] - IO.racePair(A,B) should work if A completes second in terminal error

2292[info] - IO.racePair(A,B) should work if B completes second in error

2293[info] - IO.racePair should be stack safe, take 1

2294[info] - IO.racePair should be stack safe, take 2

2295[info] - IO.racePair has a stack safe cancelable

2296[info] - IO.race(a, b) should work if a completes first

2297[info] - IO.race(a, b) should work if b completes first

2298[info] - IO.race(a, b) should cancel both

2299[info] - IO.race(a, b) should end both in error if `a` completes first in error

2300[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error

2301[info] - IO.race(a, b) should end both in error if `b` completes first in error

2302[info] - IO.race(a, b) should end both in error if `b` completes first in error

2303[info] - IO.race(a, b) should work if `a` completes in typed error

2304[info] - IO.race(a, b) should work if `a` completes in unexpected error

2305[info] - IO.race(a, b) should work if `b` completes in typed error

2306[info] - IO.race(a, b) should work if `b` completes in unexpected error

2307[info] - IO.race should be stack safe, take 1

2308[info] - IO.race should be stack safe, take 2

2309[info] - Task.race has a stack safe cancelable

2310[info] monix.bio.TaskMaterializeSuite

2311[info] - IO.now.materialize

2312[info] - IO.error.materialize

2313[info] - IO.terminate.materialize

2314[info] - IO.evalOnce.materialize should be stack safe

2315[info] - IO.eval.materialize

2316[info] - IO.defer.materialize

2317[info] - IO.defer.flatMap.materialize

2318[info] - IO.flatMap.materialize

2319[info] - IO.evalAsync.materialize

2320[info] - IO.evalAsync.flatMap.materialize

2321[info] - IO.evalAsync(error).flatMap.materialize

2322[info] - IO.now.flatMap(error).materialize

2323[info] - IO.defer(error).materialize

2324[info] - IO.deferTotal(error).materialize

2325[info] - IO.defer(error).flatMap.materialize

2326[info] - IO.now.dematerialize

2327[info] - IO.error.dematerialize

2328[info] - IO.materialize should be stack safe

2329[info] - IO.eval.materialize should work for failure

2330[info] - IO.eval.materialize should be stack safe

2331[info] - IO.now.materialize should work

2332[info] - IO.materialize on failing flatMap

2333[info] - IO.now.materialize should be stack safe

2334[info] - IO.raiseError.dematerialize

2335[info] - IO.terminate.dematerialize

2336[info] monix.bio.tracing.StackTracedContextSuite

2337[info] - push traces

2338[info] - track omitted frames

2339[info] monix.bio.TaskCreateSuite

2340[info] - can use Unit as return type

2341[info] - can use Cancelable.empty as return type

2342[info] - returning Unit yields non-cancelable tasks

2343[info] - can use Cancelable as return type

2344[info] - returning Cancelable yields a cancelable task

2345[info] - can use CIO[Unit] as return type

2346[info] - returning CIO[Unit] yields a cancelable task

2347[info] - can use IO[E, Unit] as return type

2348[info] - returning IO[E, Unit] yields a cancelable task

2349[info] - throwing error when returning Unit

2350[info] - throwing error when returning Cancelable

2351[info] monix.bio.TaskFlatMapSuite

2352[info] - runAsync flatMap loop is not cancelable if autoCancelableRunLoops=false

2353[info] - runAsync flatMap loop is cancelable if ExecutionModel permits

2354[info] - runAsync(callback) flatMap loop is cancelable if ExecutionModel permits

2355[info] - redeemWith derives flatMap

2356[info] - redeemWith derives onErrorHandleWith

2357[info] - redeem derives map . onErrorHandle

2358[info] - redeem derives onErrorHandle

2359[info] - redeemWith can recover

2360[info] - redeem can recover

2361[info] - >> is stack safe for infinite loops

2362[info] - flatMapLoop enables loops

2363[info] monix.bio.IOParZipSuite

2364[info] - IO.parZip2 should work if source finishes first

2365[info] - IO.parZip2 should work if other finishes first

2366[info] - IO.parZip2 should cancel both

2367[info] - IO.parZip2 should cancel just the source

2368[info] - IO.parZip2 should cancel just the other

2369[info] - IO.parZip2 should onError from the source before other

2370[info] - IO.parZip2 handle terminal errors from the source before other

2371[info] - IO.parZip2 should onError from the other after the source

2372[info] - IO.parZip2 should handle terminal errors from the other after the source

2373[info] - IO.parZip2 should onError from the other before the source

2374[info] - IO.parZip2 works

2375[info] - IO.map2 works

2376[info] - IO#map2 should protect against user code

2377[info] - IO.map2 runs effects in strict sequence

2378[info] - IO.parMap2 works

2379[info] - IO#parMap2 should protect against user code

2380[info] - IO.parZip3 works

2381[info] - IO#map3 works

2382[info] - IO#parMap3 works

2383[info] - IO.parZip4 works

2384[info] - IO#map4 works

2385[info] - IO#parMap4 works

2386[info] - IO.parZip5 works

2387[info] - IO#map5 works

2388[info] - IO#parMap5 works

2389[info] - IO.parZip6 works

2390[info] - IO#map6 works

2391[info] - IO#parMap6 works

2392[info] monix.bio.TaskStartSuite

2393[info] - task.start.flatMap(_.join) <-> task

2394[info] - task.start.flatMap(id) is cancelable, but the source is memoized

2395[info] - task.start is stack safe

2396[info] - task.start shares Local.Context with fibers

2397[info] - task.start is stack safe

2398[info] - task.start executes asynchronously

2399[info] monix.bio.TaskSuspendSuite

2400[info] - IO.suspend should suspend evaluation

2401[info] - IO.suspend should protect against user code errors

2402[info] - IO.suspendTotal should protect against unexpected errors

2403[info] monix.bio.TaskDoOnCancelSuite

2404[info] - doOnCancel should normally mirror the source

2405[info] - doOnCancel should mirror failed sources

2406[info] - doOnCancel should mirror terminated sources

2407[info] - doOnCancel should cancel delayResult #1

2408[info] - doOnCancel should cancel delayResult #2

2409[info] - doOnCancel should cancel delayResult #3

2410[info] - doOnCancel should cancel delayExecution #1

2411[info] - doOnCancel should cancel delayExecution #2

2412[info] - doOnCancel is stack safe in flatMap loops

2413[info] - local.write.doOnCancel works

2414[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite

2415[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2416[info] - CoflatMap[Task].coflatMap.coflatMap identity

2417[info] - CoflatMap[Task].coflatMap.coflatten coherence

2418[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2419[info] - CoflatMap[Task].coflatMap.covariant composition

2420[info] - CoflatMap[Task].coflatMap.covariant identity

2421[info] - CoflatMap[Task].coflatMap.invariant composition

2422[info] - CoflatMap[Task].coflatMap.invariant identity

2423[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2424[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2425[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2426[info] - Concurrent[Task].concurrent.ap consistent with product + map

2427[info] - Concurrent[Task].concurrent.applicative homomorphism

2428[info] - Concurrent[Task].concurrent.applicative identity

2429[info] - Concurrent[Task].concurrent.applicative interchange

2430[info] - Concurrent[Task].concurrent.applicative map

2431[info] - Concurrent[Task].concurrent.applicative unit

2432[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2433[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2434[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2435[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2436[info] - Concurrent[Task].concurrent.applicativeError handle

2437[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2438[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2439[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2440[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2441[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2442[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2443[info] - Concurrent[Task].concurrent.applicativeError handleWith

2444[info] - Concurrent[Task].concurrent.applicativeError onError pure

2445[info] - Concurrent[Task].concurrent.applicativeError onError raise

2446[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2447[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2448[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2449[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2450[info] - Concurrent[Task].concurrent.apply composition

2451[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2452[info] - Concurrent[Task].concurrent.async cancelable coherence

2453[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2454[info] - Concurrent[Task].concurrent.async left is raiseError

2455[info] - Concurrent[Task].concurrent.async right is pure

2456[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2457[info] - Concurrent[Task].concurrent.bind suspends evaluation

2458[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2459[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2460[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2461[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2462[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2463[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2464[info] - Concurrent[Task].concurrent.covariant composition

2465[info] - Concurrent[Task].concurrent.covariant identity

2466[info] - Concurrent[Task].concurrent.delay constant is pure

2467[info] - Concurrent[Task].concurrent.flatMap associativity

2468[info] - Concurrent[Task].concurrent.flatMap consistent apply

2469[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2470[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2471[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2472[info] - Concurrent[Task].concurrent.invariant composition

2473[info] - Concurrent[Task].concurrent.invariant identity

2474[info] - Concurrent[Task].concurrent.join is idempotent

2475[info] - Concurrent[Task].concurrent.map flatMap coherence

2476[info] - Concurrent[Task].concurrent.map suspends evaluation

2477[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2478[info] - Concurrent[Task].concurrent.map2/product-map consistency

2479[info] - Concurrent[Task].concurrent.monad left identity

2480[info] - Concurrent[Task].concurrent.monad right identity

2481[info] - Concurrent[Task].concurrent.monadError ensure consistency

2482[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2483[info] - Concurrent[Task].concurrent.monadError left zero

2484[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2485[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2486[info] - Concurrent[Task].concurrent.monoidal left identity

2487[info] - Concurrent[Task].concurrent.monoidal right identity

2488[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2489[info] - Concurrent[Task].concurrent.never is derived from async

2490[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2491[info] - Concurrent[Task].concurrent.productL consistent map2

2492[info] - Concurrent[Task].concurrent.productR consistent map2

2493[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2494[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2495[info] - Concurrent[Task].concurrent.race cancels both

2496[info] - Concurrent[Task].concurrent.race cancels loser

2497[info] - Concurrent[Task].concurrent.race mirrors left winner

2498[info] - Concurrent[Task].concurrent.race mirrors right winner

2499[info] - Concurrent[Task].concurrent.racePair can join left

2500[info] - Concurrent[Task].concurrent.racePair can join right

2501[info] - Concurrent[Task].concurrent.racePair cancels both

2502[info] - Concurrent[Task].concurrent.racePair cancels loser

2503[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2504[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2505[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2506[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2507[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2508[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2509[info] - Concurrent[Task].concurrent.semigroupal associativity

2510[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2511[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2512[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2513[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2514[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2515[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2516[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2517[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2518[info] - Concurrent[Task].concurrent.start then join is identity

2519[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2520[info] - Concurrent[Task].concurrent.suspend constant is pure join

2521[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2522[info] - Concurrent[Task].concurrent.tailRecM stack safety

2523[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2524[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2525[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2526[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2527[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2528[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2529[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2530[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2531[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2532[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2533[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2534[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2535[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2536[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2537[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2538[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2539[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2540[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2541[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2542[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2543[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2544[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2545[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2546[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2547[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2548[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2549[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2550[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2551[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2552[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2553[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2554[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2555[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2556[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2557[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2558[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2559[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2560[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2561[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2562[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2563[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2564[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2565[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2566[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2567[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2568[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2569[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2570[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2571[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2572[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2573[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2574[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2575[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2576[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2577[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2578[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2579[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2580[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2581[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2582[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2583[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2584[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2585[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2586[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2587[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2588[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2589[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2590[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2591[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2592[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2593[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2594[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2595[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2596[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2597[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2598[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2599[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2600[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2601[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2602[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2603[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2604[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2605[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2606[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2607[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2608[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2609[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2610[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2611[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2612[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2613[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2614[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2615[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2616[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2617[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2618[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2619[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2620[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2621[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2622[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2623[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2624[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2625[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2626[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2627[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2628[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2629[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2630[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2631[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2632[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2633[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2634[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2635[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2636[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2637[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2638[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2639[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2640[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2641[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2642[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2643[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2644[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2645[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2646[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2647[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2648[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2649[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2650[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2651[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2652[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2653[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2654[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2655[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2656[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2657[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2658[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2659[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2660[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2661[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2662[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2663[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2664[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2665[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2666[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2667[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2668[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2669[info] - Monoid[IO[String, Int]].monoid.associative

2670[info] - Monoid[IO[String, Int]].monoid.collect0

2671[info] - Monoid[IO[String, Int]].monoid.combine all

2672[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2673[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2674[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2675[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2676[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2677[info] - Monoid[IO[String, Int]].monoid.is id

2678[info] - Monoid[IO[String, Int]].monoid.left identity

2679[info] - Monoid[IO[String, Int]].monoid.repeat0

2680[info] - Monoid[IO[String, Int]].monoid.repeat1

2681[info] - Monoid[IO[String, Int]].monoid.repeat2

2682[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2683[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2684[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2685[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2686[info] - Monoid[IO[String, Int]].monoid.right identity

2687[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2688[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2689[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2690[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2691[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2692[info] monix.bio.TaskEffectInstanceSuite

2693[info] - Effect instance should make use of implicit TaskOptions

2694[info] - Effect instance should use Task.defaultOptions with default TestScheduler

2695[info] - Effect instance should use Task.defaultOptions.withSchedulerFeatures

2696[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite

2697[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2698[info] - CoflatMap[Task].coflatMap.coflatMap identity

2699[info] - CoflatMap[Task].coflatMap.coflatten coherence

2700[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2701[info] - CoflatMap[Task].coflatMap.covariant composition

2702[info] - CoflatMap[Task].coflatMap.covariant identity

2703[info] - CoflatMap[Task].coflatMap.invariant composition

2704[info] - CoflatMap[Task].coflatMap.invariant identity

2705[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

2706[info] - Concurrent[Task].async.ap consistent with product + map

2707[info] - Concurrent[Task].async.applicative homomorphism

2708[info] - Concurrent[Task].async.applicative identity

2709[info] - Concurrent[Task].async.applicative interchange

2710[info] - Concurrent[Task].async.applicative map

2711[info] - Concurrent[Task].async.applicative unit

2712[info] - Concurrent[Task].async.applicativeError adaptError pure

2713[info] - Concurrent[Task].async.applicativeError adaptError raise

2714[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

2715[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

2716[info] - Concurrent[Task].async.applicativeError handle

2717[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

2718[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

2719[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

2720[info] - Concurrent[Task].async.applicativeError handleError pure

2721[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

2722[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

2723[info] - Concurrent[Task].async.applicativeError handleWith

2724[info] - Concurrent[Task].async.applicativeError onError pure

2725[info] - Concurrent[Task].async.applicativeError onError raise

2726[info] - Concurrent[Task].async.applicativeError pure attempt

2727[info] - Concurrent[Task].async.applicativeError raiseError attempt

2728[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

2729[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

2730[info] - Concurrent[Task].async.apply composition

2731[info] - Concurrent[Task].async.async can be derived from asyncF

2732[info] - Concurrent[Task].async.async left is raiseError

2733[info] - Concurrent[Task].async.async right is pure

2734[info] - Concurrent[Task].async.bind suspends evaluation

2735[info] - Concurrent[Task].async.bracket is derived from bracketCase

2736[info] - Concurrent[Task].async.bracket release is called on Completed or Error

2737[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

2738[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

2739[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2740[info] - Concurrent[Task].async.covariant composition

2741[info] - Concurrent[Task].async.covariant identity

2742[info] - Concurrent[Task].async.delay constant is pure

2743[info] - Concurrent[Task].async.flatMap associativity

2744[info] - Concurrent[Task].async.flatMap consistent apply

2745[info] - Concurrent[Task].async.flatMap from tailRecM consistency

2746[info] - Concurrent[Task].async.guarantee is derived from bracket

2747[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

2748[info] - Concurrent[Task].async.invariant composition

2749[info] - Concurrent[Task].async.invariant identity

2750[info] - Concurrent[Task].async.map flatMap coherence

2751[info] - Concurrent[Task].async.map suspends evaluation

2752[info] - Concurrent[Task].async.map2/map2Eval consistency

2753[info] - Concurrent[Task].async.map2/product-map consistency

2754[info] - Concurrent[Task].async.monad left identity

2755[info] - Concurrent[Task].async.monad right identity

2756[info] - Concurrent[Task].async.monadError ensure consistency

2757[info] - Concurrent[Task].async.monadError ensureOr consistency

2758[info] - Concurrent[Task].async.monadError left zero

2759[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

2760[info] - Concurrent[Task].async.monadError rethrow attempt

2761[info] - Concurrent[Task].async.monoidal left identity

2762[info] - Concurrent[Task].async.monoidal right identity

2763[info] - Concurrent[Task].async.mproduct consistent flatMap

2764[info] - Concurrent[Task].async.never is derived from async

2765[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

2766[info] - Concurrent[Task].async.productL consistent map2

2767[info] - Concurrent[Task].async.productR consistent map2

2768[info] - Concurrent[Task].async.propagate errors through bind (async)

2769[info] - Concurrent[Task].async.propagate errors through bind (suspend)

2770[info] - Concurrent[Task].async.repeated async evaluation not memoized

2771[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

2772[info] - Concurrent[Task].async.repeated sync evaluation not memoized

2773[info] - Concurrent[Task].async.semigroupal associativity

2774[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

2775[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

2776[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

2777[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

2778[info] - Concurrent[Task].async.stack-safe on left-associated binds

2779[info] - Concurrent[Task].async.stack-safe on repeated attempts

2780[info] - Concurrent[Task].async.stack-safe on repeated maps

2781[info] - Concurrent[Task].async.stack-safe on right-associated binds

2782[info] - Concurrent[Task].async.suspend constant is pure join

2783[info] - Concurrent[Task].async.tailRecM consistent flatMap

2784[info] - Concurrent[Task].async.tailRecM stack safety

2785[info] - Concurrent[Task].async.throw in delay is raiseError

2786[info] - Concurrent[Task].async.throw in suspend is raiseError

2787[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

2788[info] - Concurrent[Task].async.unsequenced delay is no-op

2789[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

2790[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

2791[info] - ConcurrentEffect[Task].effect.applicative homomorphism

2792[info] - ConcurrentEffect[Task].effect.applicative identity

2793[info] - ConcurrentEffect[Task].effect.applicative interchange

2794[info] - ConcurrentEffect[Task].effect.applicative map

2795[info] - ConcurrentEffect[Task].effect.applicative unit

2796[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

2797[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

2798[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

2799[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

2800[info] - ConcurrentEffect[Task].effect.applicativeError handle

2801[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

2802[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

2803[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

2804[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

2805[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

2806[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

2807[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

2808[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

2809[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

2810[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

2811[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

2812[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

2813[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

2814[info] - ConcurrentEffect[Task].effect.apply composition

2815[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

2816[info] - ConcurrentEffect[Task].effect.async left is raiseError

2817[info] - ConcurrentEffect[Task].effect.async right is pure

2818[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

2819[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

2820[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

2821[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

2822[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

2823[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2824[info] - ConcurrentEffect[Task].effect.covariant composition

2825[info] - ConcurrentEffect[Task].effect.covariant identity

2826[info] - ConcurrentEffect[Task].effect.delay constant is pure

2827[info] - ConcurrentEffect[Task].effect.flatMap associativity

2828[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

2829[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

2830[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

2831[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

2832[info] - ConcurrentEffect[Task].effect.invariant composition

2833[info] - ConcurrentEffect[Task].effect.invariant identity

2834[info] - ConcurrentEffect[Task].effect.map flatMap coherence

2835[info] - ConcurrentEffect[Task].effect.map suspends evaluation

2836[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

2837[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

2838[info] - ConcurrentEffect[Task].effect.monad left identity

2839[info] - ConcurrentEffect[Task].effect.monad right identity

2840[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

2841[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

2842[info] - ConcurrentEffect[Task].effect.monadError left zero

2843[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

2844[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

2845[info] - ConcurrentEffect[Task].effect.monoidal left identity

2846[info] - ConcurrentEffect[Task].effect.monoidal right identity

2847[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

2848[info] - ConcurrentEffect[Task].effect.never is derived from async

2849[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

2850[info] - ConcurrentEffect[Task].effect.productL consistent map2

2851[info] - ConcurrentEffect[Task].effect.productR consistent map2

2852[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

2853[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

2854[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

2855[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

2856[info] - ConcurrentEffect[Task].effect.repeated callback ignored

2857[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

2858[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

2859[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

2860[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

2861[info] - ConcurrentEffect[Task].effect.semigroupal associativity

2862[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

2863[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

2864[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

2865[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

2866[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

2867[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

2868[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

2869[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

2870[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

2871[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

2872[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

2873[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

2874[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

2875[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

2876[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

2877[info] - ConcurrentEffect[Task].effect.toIO stack safety

2878[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

2879[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

2880[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2881[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2882[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2883[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2884[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2885[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2886[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2887[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2888[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2889[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2890[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2891[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2892[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2893[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2894[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2895[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2896[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2897[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2898[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2899[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2900[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2901[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2902[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2903[info] - Monoid[IO[Throwable, Int]].monoid.associative

2904[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2905[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2906[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2907[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2908[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2909[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2910[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2911[info] - Monoid[IO[Throwable, Int]].monoid.is id

2912[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2913[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2914[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2915[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2916[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2917[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2918[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2919[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2920[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2921[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2922[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2923[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2924[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2925[info] monix.bio.TaskParTraverseNSuite

2926[info] - IO.parTraverseN allows fully sequential execution

2927[info] - IO.parTraverseN allows fully concurrent execution

2928[info] - IO.parTraverseN allows partially concurrent execution

2929[info] - IO.parTraverseN returns an error when fully sequential execution fails in a typed way

2930[info] - IO.parTraverseN returns an error when fully sequential execution fails in a terminal way

2931[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a typed way

2932[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a terminal way

2933[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a typed way

2934[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a terminal way

2936[info] - IO.parTraverseN should be cancelable

2937[info] - IO.parTraverseN should be stack safe for synchronous tasks with low parallelism

2938[info] - IO.parTraverseN should be stack safe for asynchronous tasks with low parallelism

2939[info] - IO.parTraverseN should be stack safe for synchronous tasks with high parallelism

2940[info] - IO.parTraverseN should be stack safe for asynchronous tasks with high parallelism

2941[info] - IO.parTraverseN allows running the same effect multiple times

2942[info] - IO.parTraverseN allows reusing a memoized effect multiple times

2943[info] monix.bio.TaskParSequenceNSuite

2944[info] - IO.parSequenceN should execute in parallel bounded by parallelism

2945[info] - IO.parSequenceN should return result in order

2946[info] - IO.parSequenceN should return empty list

2947[info] - IO.parSequenceN should handle single item

2948[info] - IO.parSequenceN should handle parallelism bigger than list

2949[info] - IO.parSequenceN should onError if one of the tasks terminates in error

2950[info] - IO.parSequenceN should onTerminate if one of the tasks terminates in a fatal error

2951[info] - IO.parSequenceN should be canceled

2952[info] - IO.parSequenceN should be stack safe for synchronous tasks

2953[info] - IO.parSequenceN runAsync multiple times

2954[info] - IO.parSequenceN should log errors if multiple errors happen

2955[info] - IO.parSequenceN should log terminal errors if multiple errors happen

2956Hello!

2958************************

2959Build summary:

2960[{

2961 "module": "monix-bio",

2962 "compile": {"status": "ok", "tookMs": 16326, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2963 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2964 "test-compile": {"status": "ok", "tookMs": 33649, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2965 "test": {"status": "ok", "tookMs": 27061, "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: 80 s (0:01:20.0), completed Jan 13, 2026, 7:32:14 PM

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.