Build Logs

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

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

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

4Note: switching to '471cbe3ecf13687c2c57b1e64b02818684ac2165'.

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

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

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

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

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

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

15Or undo this operation with:

17 git switch -

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

21----

22Preparing build for 3.8.0-RC5

23Scala binary version found: 3.8

24Implicitly using source version 3.8

25Scala binary version found: 3.8

26Implicitly using source version 3.8

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

28Append: ,REQUIRE:-source:3.8

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

30----

31Starting build for 3.8.0-RC5

32Execute tests: true

33sbt project found:

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

35Enforcing usage of sbt in version 1.11.5

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

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

38Scala version: 3.8.0-RC5

39Targets: io.monix%monix-bio

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

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

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

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

44[sbt_options] declare -a sbt_options=()

45[process_args] java_version = '17'

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

47# Executing command line:

48java

49-Dfile.encoding=UTF-8

50-Dcommunitybuild.scala=3.8.0-RC5

51-Dcommunitybuild.project.dependencies.add=

52-Xmx7G

53-Xms4G

54-Xss8M

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

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

57-jar

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

59"setCrossScalaVersions 3.8.0-RC5"

60"++3.8.0-RC5 -v"

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

62"set every credentials := Nil"

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

64"removeScalacOptionsStartingWith -P:wartremover"

66moduleMappings

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

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

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

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

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

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

74[info] Compilation completed in 9.591s.

75[info] done compiling

77 unmanagedSourceDirectories in FullTracingTest += {

78 ^

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

81 ^

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

84 ^

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

87 ^

89 fork in Test := true,

90 ^

92 fork in FullTracingTest := true,

93 ^

95 javaOptions in Test ++= Seq(

96 ^

98 javaOptions in FullTracingTest ++= Seq(

99 ^

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

102 ^

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

105 ^

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

108 ^

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

111 ^

113 .dependsOn(unidoc in Compile)

114 ^

116 .dependsOn(updateSiteVariables in ThisBuild)

117 ^

119 .dependsOn(unidoc in Compile)

120 ^

122 .dependsOn(updateSiteVariables in ThisBuild)

123 ^

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

126 ^

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

129 ^

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

132 ^

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

135 ^

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

138 ^

140 publishArtifact in (Compile, packageBin) := false

141 ^

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

144 ^

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

147 ^

149 scalacOptions in ThisBuild ++= Seq(

150 ^

152 resolvers += Resolver.sonatypeCentralSnapshots

154 Resolver.sonatypeRepo("releases")

155 ^

157 publishArtifact in Test := false,

158 ^

160 unmanagedSourceDirectories in Compile += {

161 ^

163 unmanagedSourceDirectories in Test += {

164 ^

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

167 ^

169 skip in publish := true,

170 ^

172updateSiteVariables in ThisBuild := {

173 ^

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

176 ^

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

179 ^

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

182 ^

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

185 ^

187mimaFailOnNoPrevious in ThisBuild := false

188 ^

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

191 ^

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

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

194Execute setCrossScalaVersions: 3.8.0-RC5

195OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC5 in coreJVM/crossScalaVersions

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

197OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC5 in benchmarks/crossScalaVersions

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

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

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

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

202[info] Switching Scala version on:

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

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

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

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

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

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 Dec 31, 2025, 9:22:04 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.0-RC5/classes ...

246[info] done compiling

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

250[info] done compiling

251[info] monix.bio.TaskEffectInstanceSuite

252[info] - Effect instance should make use of implicit TaskOptions

253[info] - Effect instance should use Task.defaultOptions with default TestScheduler

254[info] - Effect instance should use Task.defaultOptions.withSchedulerFeatures

255[info] monix.bio.IODoOnFinishSuite

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

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

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

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

260[info] monix.bio.TaskSequenceSuite

261[info] - IO.sequence should not execute in parallel

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

263[info] - IO.sequence should onTerminate if one of the tasks terminates in error

264[info] - IO.sequence should be canceled

265[info] monix.bio.IOParZipSuite

266[info] - IO.parZip2 should work if source finishes first

267[info] - IO.parZip2 should work if other finishes first

268[info] - IO.parZip2 should cancel both

269[info] - IO.parZip2 should cancel just the source

270[info] - IO.parZip2 should cancel just the other

271[info] - IO.parZip2 should onError from the source before other

272[info] - IO.parZip2 handle terminal errors from the source before other

273[info] - IO.parZip2 should onError from the other after the source

274[info] - IO.parZip2 should handle terminal errors from the other after the source

275[info] - IO.parZip2 should onError from the other before the source

276[info] - IO.parZip2 works

277[info] - IO.map2 works

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

279[info] - IO.map2 runs effects in strict sequence

280[info] - IO.parMap2 works

281[info] - IO#parMap2 should protect against user code

282[info] - IO.parZip3 works

283[info] - IO#map3 works

284[info] - IO#parMap3 works

285[info] - IO.parZip4 works

286[info] - IO#map4 works

287[info] - IO#parMap4 works

288[info] - IO.parZip5 works

289[info] - IO#map5 works

290[info] - IO#parMap5 works

291[info] - IO.parZip6 works

292[info] - IO#map6 works

293[info] - IO#parMap6 works

294[info] monix.bio.TaskMaterializeSuite

295[info] - IO.now.materialize

296[info] - IO.error.materialize

297[info] - IO.terminate.materialize

298[info] - IO.evalOnce.materialize should be stack safe

299[info] - IO.eval.materialize

300[info] - IO.defer.materialize

301[info] - IO.defer.flatMap.materialize

302[info] - IO.flatMap.materialize

303[info] - IO.evalAsync.materialize

304[info] - IO.evalAsync.flatMap.materialize

305[info] - IO.evalAsync(error).flatMap.materialize

306[info] - IO.now.flatMap(error).materialize

307[info] - IO.defer(error).materialize

308[info] - IO.deferTotal(error).materialize

309[info] - IO.defer(error).flatMap.materialize

310[info] - IO.now.dematerialize

311[info] - IO.error.dematerialize

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

313[info] - IO.eval.materialize should work for failure

314[info] - IO.eval.materialize should be stack safe

315[info] - IO.now.materialize should work

316[info] - IO.materialize on failing flatMap

317[info] - IO.now.materialize should be stack safe

318[info] - IO.raiseError.dematerialize

319[info] - IO.terminate.dematerialize

320[info] monix.bio.TaskDoOnCancelSuite

321[info] - doOnCancel should normally mirror the source

322[info] - doOnCancel should mirror failed sources

323[info] - doOnCancel should mirror terminated sources

324[info] - doOnCancel should cancel delayResult #1

325[info] - doOnCancel should cancel delayResult #2

326[info] - doOnCancel should cancel delayResult #3

327[info] - doOnCancel should cancel delayExecution #1

328[info] - doOnCancel should cancel delayExecution #2

329[info] - doOnCancel is stack safe in flatMap loops

330[info] - local.write.doOnCancel works

331[info] monix.bio.TaskExecutionModelSuite

332[info] - IO.now.executeWithModel(AlwaysAsyncExecution) should work

333[info] - IO.now.runAsync (CancelableFuture) should not be async with AlwaysAsyncExecution

334[info] - IO.eval.executeWithModel(AlwaysAsyncExecution) should work

335[info] - IO.eval should be async with AlwaysAsyncExecution

336[info] - IO.now.flatMap loops should work with AlwaysAsyncExecution

337[info] - IO.eval.flatMap loops should work with AlwaysAsyncExecution

338[info] - IO.flatMap loops should work with AlwaysAsyncExecution

339[info] monix.bio.TaskDelaySuite

340[info] - IO#delayExecution should work

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

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

343[info] - IO#delayExecution is cancelable

344[info] - IO#delayResult should work

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

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

347[info] - IO#delayResult is cancelable

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

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

350[info] monix.bio.TaskCallbackSafetySuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

368[info] monix.bio.TaskConnectionSuite

369[info] - initial push

370[info] - cancels Task after being canceled

371[info] - cancels Cancelable after being canceled

372[info] - cancels CancelableF after being canceled

373[info] - push two, pop one

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

375[info] - push two, pop two

376[info] - push(Cancelable)

377[info] - push(Cancelable) then pop

378[info] - push(CancelToken)

379[info] - push(CancelToken) then pop

380[info] - pop when self is empty

381[info] - pop when self is canceled

382[info] - cancel mixture

383[info] - cancel mixture after being cancelled

384[info] - tryReactive

385[info] - toCancelable

386[info] - uncancelable ref is shared

387[info] - uncancelable ops

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

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

390[info] - throwing error in Task after cancel

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

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

393[info] - throwing error in Cancelable after cancel

394[info] monix.bio.TaskLikeConversionsJava8Suite

395[info] - IO.from converts successful CompletableFuture

396[info] - IO.from converts failed CompletableFuture

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

398[info] monix.bio.TaskMemoizeSuite

399[info] - IO.memoize should work asynchronously for first subscriber

400[info] - IO.memoize should work synchronously for next subscribers

401[info] - IO.memoize should be stack safe

402[info] - IO.flatMap.memoize should be stack safe, test 1

403[info] - IO.flatMap.memoize should be stack safe, test 2

404[info] - IO.raiseError(error).memoize should work

405[info] - IO.terminate(error).memoize should work

406[info] - IO.memoize.materialize

407[info] - IO.apply(error).memoize.materialize

408[info] - IO.eval.memoize should work for first subscriber

409[info] - IO.eval.memoize should work synchronously for next subscribers

410[info] - IO.eval(error).memoize should work

411[info] - IO.eval.memoize

412[info] - IO.eval.memoize should be stack safe

413[info] - IO.eval.flatMap.memoize should be stack safe

414[info] - IO.defer(evalAlways).memoize

415[info] - IO.evalOnce.memoize should work for first subscriber

416[info] - IO.evalOnce.memoize should work synchronously for next subscribers

417[info] - IO.evalOnce(error).memoize should work

418[info] - IO.evalOnce.memoize should be stack safe

419[info] - IO.evalOnce.flatMap.memoize should be stack safe

420[info] - IO.now.memoize should work synchronously for first subscriber

421[info] - IO.now.memoize should work synchronously for next subscribers

422[info] - IO.error.memoize should work

423[info] - IO.now.memoize should be stack safe

424[info] - IO.now.flatMap.memoize should be stack safe

425[info] - IO.defer.memoize should be stack safe

426[info] - IO.memoize effects, sequential

427[info] - IO.memoize effects, parallel

428[info] - IO.suspend.memoize effects

429[info] - IO.suspend.flatMap.memoize effects

430[info] - IO.memoize should make subsequent subscribers wait for the result, as future

431[info] - IO.memoize should make subsequent subscribers wait for the result, as callback

432[info] - Task.memoize should be synchronous for subsequent subscribers, as callback

433[info] - IO.memoize should not be cancelable (future)

434[info] - IO.memoize should be cancelable (callback, #1)

435[info] - IO.memoize should be cancelable (callback, #2)

436[info] - IO.memoize should be re-executable after cancel

437[info] - IO.memoize should not be uninterruptible

438[info] - IO.memoize serves error after async boundary

439[info] - TaskRunLoop.startLightWithBiCallback for success

440[info] - TaskRunLoop.startLightWithBiCallback for failure

441[info] - IO.evalOnce eq IO.evalOnce.memoize

442[info] - IO.eval.memoize eq IO.eval.memoize.memoize

443[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoize

444[info] - IO.now.memoize eq IO.now

445[info] - IO.raiseError.memoize eq IO.raiseError

446[info] - IO.terminate.memoize eq IO.raiseError

447[info] - IO.eval.memoizeOnSuccess.memoize !== IO.eval.memoizeOnSuccess

448[info] monix.bio.BIOAppSuite

449[info] - run works

450[info] - options are configurable

451[info] - ConcurrentEffect[Task]

452[info] monix.bio.TaskToStringSuite

453[info] - IO.Now

454[info] - IO.Error

455[info] - IO.Termination

456[info] - IO.Eval

457[info] - IO.EvalTotal

458[info] - IO.Async

459[info] - IO.FlatMap

460[info] - IO.Suspend

461[info] - IO.SuspendTotal

462[info] - IO.Map

463[info] monix.bio.TaskCallbackSafetyJVMSuite

464[info] - IO.async has a safe callback

465[info] - IO.async0 has a safe callback

466[info] - IO.asyncF has a safe callback

467[info] - IO.cancelable has a safe callback

468[info] - IO.cancelable0 has a safe callback

469[info] monix.bio.TaskToFutureSuite

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

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

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

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

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

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

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

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

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

479[info] - Task.fromFuture async result

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

481[info] - Task.deferFuture async result

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

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

484[info] - Task.deferFutureAction async result

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

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

487[info] - Task.fromFuture(cancelable)

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

489[info] - Task.deferFuture(cancelable)

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

491[info] - Task.deferFutureAction(cancelable)

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

493[info] monix.bio.TaskEvalAsyncSuite

494[info] - IO.evalAsync should work, on different thread

495[info] - IO.evalAsync should protect against user code errors

496[info] - UIO.evalAsync should protect against user code errors

497[info] - IO.evalAsync is equivalent with IO.eval

498[info] - IO.evalAsync is equivalent with IO.evalOnce on first run

499[info] - IO.evalAsync.flatMap should protect against user code

500[info] - IO.evalAsync should be tail recursive

501[info] - IO.evalAsync.flatten is equivalent with flatMap

502[info] - IO.evalAsync.coeval

503[info] monix.bio.TaskFlipSuite

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

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

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

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

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

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

510[info] monix.bio.TaskFromFutureSuite

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

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

513[info] - Task.fromFuture should work onSuccess

514[info] - Task.fromFuture should work onError

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

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

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

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

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

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

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

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

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

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

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

526[info] monix.bio.IOLocalSuite

527[info] - IOLocal.apply

528[info] - IOLocal.wrap

529[info] - IOLocal!.bind

530[info] - IOLocal!.bindL

531[info] - IOLocal!.bindClear

532[info] - IOLocal canceled

533[info] - IOLocal!.local

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

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

536[info] - IOLocal should work with bracket

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

538[info] - IOLocal interop with future via deferFutureAction

539[info] - IOLocal.bind scoping works

540[info] - IOLocal.bind actually isolates reads

541[info] - IOLocal.isolate with ConcurrentChannel

542[info] monix.bio.IOMapNSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

563[info] monix.bio.TaskConnectionRefSuite

564[info] - assign and cancel a Cancelable

565[info] - assign and cancel a CancelableF

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

567[info] - cancel a Cancelable on single assignment

568[info] - cancel a CancelableF on single assignment

569[info] - cancel a Task on single assignment

570[info] monix.bio.TaskRejectedExecutionSuite

572[info] monix.bio.TaskMemoizeOnSuccessSuite

573[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber

574[info] - IO.memoizeOnSuccess should work synchronously for next subscribers

575[info] - IO.memoizeOnSuccess should be stack safe

576[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1

577[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2

578[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent

579[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent

580[info] - IO.memoizeOnSuccess.materialize

581[info] - IO.raiseError(error).memoizeOnSuccess.materialize

582[info] - IO.terminate(error).memoizeOnSuccess.materialize

583[info] - IO.eval.memoizeOnSuccess should work for first subscriber

584[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers

585[info] - IO.eval(error).memoizeOnSuccess should not be idempotent

586[info] - IO.eval.memoizeOnSuccess

587[info] - IO.eval.memoizeOnSuccess should be stack safe

588[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe

589[info] - IO.defer(evalAlways).memoizeOnSuccess

590[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber

591[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers

592[info] - IO.evalOnce(error).memoizeOnSuccess should work

593[info] - IO.evalOnce.memoizeOnSuccess should be stack safe

594[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe

595[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber

596[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers

597[info] - IO.raiseError.memoizeOnSuccess should work

598[info] - IO.terminate.memoizeOnSuccess should work

599[info] - IO.now.memoizeOnSuccess should be stack safe

600[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe

601[info] - IO.suspend.memoizeOnSuccess should be stack safe

602[info] - IO.memoizeOnSuccess effects, sequential

603[info] - IO.memoizeOnSuccess effects, parallel

604[info] - IO.suspend.memoizeOnSuccess effects

605[info] - IO.suspend.flatMap.memoizeOnSuccess effects

606[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future

607[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback

608[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback

609[info] - IO.memoizeOnSuccess should be cancellable (future)

610[info] - IO.memoizeOnSuccess should be cancellable (callback #1)

611[info] - IO.memoizeOnSuccess should be cancellable (callback #2)

612[info] - IO.memoizeOnSuccess should not be cancelable

613[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners

614[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess

615[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess

616[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess

617[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess

618[info] - IO.now.memoizeOnSuccess eq IO.now

619[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError

620[info] - IO.terminate.memoizeOnSuccess eq IO.terminate

621[info] monix.bio.TaskSuspendSuite

622[info] - IO.suspend should suspend evaluation

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

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

625[info] monix.bio.TaskBimapSuite

626[info] - IO.bimap should map the success channel

627[info] - IO.bimap should map the error channel

628[info] monix.bio.TaskCallbackSuite

629[info] - onValue should invoke onSuccess

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

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

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

633[info] - contramap should pipe onError

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

635[info] - BiCallback.fromPromise (success)

636[info] - BiCallback.fromPromise (failure)

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

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

639[info] - BiCallback.empty reports errors

640[info] - BiCallback.empty reports terminal errors

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

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

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

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

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

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

647[info] - fromAttempt success

648[info] - fromAttempt error

649[info] - fromAttempt termination

650value1: 0

651value2: 100

652value3: 400

653value4: 100

654value5: 0

655[info] monix.bio.IOLocalDoctest

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

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

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

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

660[info] monix.bio.TaskRaceSuite

661[info] - IO.raceMany returns fastest success

662[info] - IO.raceMany returns fastest typed error

663[info] - IO.raceMany returns fastest terminal error

664[info] - IO.raceMany returns success that is faster than typed error

665[info] - IO.raceMany returns success that is faster than terminal error

666[info] - IO.raceMany returns typed error that is faster than success

667[info] - IO.raceMany returns typed error that is faster than fatal error

668[info] - IO.raceMany returns fatal error that is faster than success

669[info] - IO.raceMany returns fatal error that is faster than typed error

670[info] - IO.raceMany should allow cancelling all tasks

671[info] - IO.raceMany should be stack safe for sync values

672[info] - IO.raceMany should be stack safe for async values

673[info] - IO.raceMany has a stack safe cancelable

674[info] - IO#timeout should timeout

675[info] - IO#timeout should mirror the source in case of success

676[info] - IO#timeout should mirror the source in case of error

677[info] - IO#timeout should mirror the source in case of terminal error

678[info] - IO#timeout should cancel both the source and the timer

679[info] - IO#timeout with backup should timeout

680[info] - IO#timeout with backup should timeout with error

681[info] - IO#timeout with backup should mirror the source in case of success

682[info] - IO#timeout with backup should mirror the source in case of error

683[info] - IO#timeout should cancel both the source and the timer

684[info] - IO#timeout should cancel the backup

685[info] - IO#timeout should not return the source after timeout

686[info] - IO#timeout should cancel the source after timeout

687[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization

688[info] - IO#timeoutL should evaluate as specified: lazy, with memoization

689[info] - IO#timeoutL considers time taken to evaluate the duration task

690[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed

691[info] - IO.racePair(a,b) should work if a completes first

692[info] - IO.racePair(a,b) should cancel both

693[info] - IO.racePair(A,B) should not cancel B if A completes first

694[info] - IO.racePair(A,B) should not cancel A if B completes first

695[info] - IO.racePair(A,B) should end both in error if A completes first in error

696[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error

697[info] - IO.racePair(A,B) should end both in error if B completes first in error

698[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error

699[info] - IO.racePair(A,B) should work if A completes second in error

700[info] - IO.racePair(A,B) should work if A completes second in terminal error

701[info] - IO.racePair(A,B) should work if B completes second in error

702[info] - IO.racePair should be stack safe, take 1

703[info] - IO.racePair should be stack safe, take 2

704[info] - IO.racePair has a stack safe cancelable

705[info] - IO.race(a, b) should work if a completes first

706[info] - IO.race(a, b) should work if b completes first

707[info] - IO.race(a, b) should cancel both

708[info] - IO.race(a, b) should end both in error if `a` completes first in error

709[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error

710[info] - IO.race(a, b) should end both in error if `b` completes first in error

711[info] - IO.race(a, b) should end both in error if `b` completes first in error

712[info] - IO.race(a, b) should work if `a` completes in typed error

713[info] - IO.race(a, b) should work if `a` completes in unexpected error

714[info] - IO.race(a, b) should work if `b` completes in typed error

715[info] - IO.race(a, b) should work if `b` completes in unexpected error

716[info] - IO.race should be stack safe, take 1

717[info] - IO.race should be stack safe, take 2

718[info] - Task.race has a stack safe cancelable

719[info] monix.bio.TaskExecuteWithOptionsSuite

720[info] - executeWithOptions works

721[info] - local.write.executeWithOptions

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

723[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

952[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1180[info] - Applicative[Task.Par].applicative.ap consistent with product + map

1181[info] - Applicative[Task.Par].applicative.applicative homomorphism

1182[info] - Applicative[Task.Par].applicative.applicative identity

1183[info] - Applicative[Task.Par].applicative.applicative interchange

1184[info] - Applicative[Task.Par].applicative.applicative map

1185[info] - Applicative[Task.Par].applicative.applicative unit

1186[info] - Applicative[Task.Par].applicative.apply composition

1187[info] - Applicative[Task.Par].applicative.covariant composition

1188[info] - Applicative[Task.Par].applicative.covariant identity

1189[info] - Applicative[Task.Par].applicative.invariant composition

1190[info] - Applicative[Task.Par].applicative.invariant identity

1191[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

1192[info] - Applicative[Task.Par].applicative.map2/product-map consistency

1193[info] - Applicative[Task.Par].applicative.monoidal left identity

1194[info] - Applicative[Task.Par].applicative.monoidal right identity

1195[info] - Applicative[Task.Par].applicative.productL consistent map2

1196[info] - Applicative[Task.Par].applicative.productR consistent map2

1197[info] - Applicative[Task.Par].applicative.semigroupal associativity

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1224[info] monix.bio.TaskParSequenceNSuite

1225[info] - IO.parSequenceN should execute in parallel bounded by parallelism

1226[info] - IO.parSequenceN should return result in order

1227[info] - IO.parSequenceN should return empty list

1228[info] - IO.parSequenceN should handle single item

1229[info] - IO.parSequenceN should handle parallelism bigger than list

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

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

1232[info] - IO.parSequenceN should be canceled

1233[info] - IO.parSequenceN should be stack safe for synchronous tasks

1234[info] - IO.parSequenceN runAsync multiple times

1235[info] - IO.parSequenceN should log errors if multiple errors happen

1236[info] - IO.parSequenceN should log terminal errors if multiple errors happen

1237[info] monix.bio.TaskEvalAlwaysSuite

1238[info] - IO.eval should work synchronously

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

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

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

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

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

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

1245[info] - IO.eval.coeval

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

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

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

1249[info] monix.bio.TaskExecuteOnSuite

1250[info] - executeOn(forceAsync = false)

1251[info] - executeOn(forceAsync = true)

1252[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1

1253[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2

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

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

1256[info] monix.bio.TaskVoidSuite

1257[info] - IO.void should work

1258[info] monix.bio.IOStartAndForgetSuite

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

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

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

1262[info] - IO#startAndForget is stack safe

1263[info] monix.bio.TaskTerminationSuite

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

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

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

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

1268[info] - IO#redeemCauseWith derives flatMap

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

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

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

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

1273[info] monix.bio.TaskTraverseSuite

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

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

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

1277[info] - IO.traverse should be canceled

1278[info] monix.bio.tracing.StackTracedContextSuite

1279[info] - push traces

1280[info] - track omitted frames

1281[info] monix.bio.TaskBracketSuite

1282[info] - equivalence with onErrorHandleWith

1283[info] - equivalence with flatMap + redeemWith

1284[info] - equivalence with flatMap + redeemCauseWith

1285[info] - use is protected against user error

1286[info] - release is evaluated on success

1287[info] - release is evaluated on error

1288[info] - release is evaluated on terminal error

1289[info] - release is evaluated on cancel

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

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

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

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

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

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

1296[info] - use is not evaluated on cancel

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

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

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

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

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

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

1303[info] - Multiple cancel should not hang

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

1305[info] - bracket can be canceled while terminating

1306[info] monix.bio.TaskTimedSuite

1307[info] - measure tasks with no errors

1308[info] - not measure tasks with typed errors

1309[info] - not measure tasks with terminal errors

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

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

1312[info] - stack safety

1313[info] monix.bio.IOLikeDoctest

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

1315[info] monix.bio.TaskErrorSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1338[info] - IO.onErrorRestart should retry onError

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

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

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

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

1343[info] - IO.onErrorRestartIf should retry onError

1344[info] - IO.onErrorRestartIf should emit onError

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

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

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

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

1349[info] - IO#onErrorRecoverWith should recover

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

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

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

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

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

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

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

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

1362[info] - Task.onErrorRestartLoop works for success

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

1364[info] - Task.onErrorRestartLoop can rethrow

1365[info] monix.bio.TaskExecuteAsyncSuite

1366[info] - IO.now.executeAsync should execute async

1367[info] - IO.now.executeOn should execute async if forceAsync = true

1368[info] - IO.now.executeOn should not execute async if forceAsync = false

1369[info] - IO.create.executeOn should execute async

1370[info] - executeAsync should be stack safe, test 1

1371[info] - IO.executeOn should be stack safe, test 2

1372[info] - executeAsync should be stack safe, test 3

1373[info] monix.bio.TaskMapBothSuite

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

1375[info] - sum two async tasks

1376[info] - sum two synchronous tasks

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

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

1379[info] - should have a stack safe cancelable

1380[info] - sum random synchronous tasks

1381[info] - sum random asynchronous tasks

1382[info] - both task can fail with error

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

1384[info] monix.bio.TaskBlockingSuite

1385[info] - blocking on future should work

1386[info] - blocking on async

1387[info] - blocking on async.flatMap

1388[info] - blocking with Termination result

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

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

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

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

1393[info] - blocking on memoize

1395[info] - IO.attempt.runSyncUnsafe works

1396[info] monix.bio.TaskConnectionCompositeSuite

1397[info] - cancels Cancelable references

1398[info] - cancels Cancelable references after cancel on assignment

1399[info] - cancels Task references

1400[info] - cancels Task references after cancel on assignment

1401[info] - cancels CancelableF references

1402[info] - cancels CancelableF references after cancel on assignment

1403[info] - addAll

1404[info] - remove Task

1405[info] - remove Cancelable

1406[info] - remove CancelableF

1407[info] monix.bio.TaskParTraverseUnorderedSuite

1408[info] - IO.parTraverseUnordered should execute in parallel

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

1410[info] - IO.parTraverseUnordered should be canceled

1411[info] - IO.parTraverseUnordered should run over an iterable

1412[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks

1413[info] - IO.parTraverseUnordered should be stack safe on success

1414[info] - IO.parTraverseUnordered should log errors if multiple errors happen

1415[info] - IO.parTraverseUnordered runAsync multiple times

1417[info] monix.bio.TaskCancellationSuite

1418[info] - cancellation works for async actions

1419[info] - cancellation works for autoCancelableRunLoops

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

1421[info] - uncancelable works for async actions

1422[info] - uncancelable works for autoCancelableRunLoops

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

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

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

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

1427[info] - cancelBoundary happy path

1428[info] - cancelBoundary execution is immediate

1429[info] - cancelBoundary is stack safe

1430[info] - cancelBoundary cancels

1431[info] - onCancelRaiseError resets cancellation flag

1432[info] - errors raised after cancel get reported

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

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

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

1436[info] - local.write.uncancelable works

1437[info] - local.write.onCancelRaiseError works

1438[info] monix.bio.TaskLikeConversionsSuite

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

1440[info] - IO.from converts successful Future

1441[info] - IO.from converts failed Future

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

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

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

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

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

1447[info] - IO.from converts successful Eval

1448[info] - IO.from converts failed Eval

1449[info] - IO.from preserves Eval laziness

1450[info] - IO.from converts successful SyncIO

1451[info] - IO.from converts failed SyncIO

1452[info] - IO.from converts successful Try

1453[info] - IO.from converts failed Try

1454[info] - IO.from converts right Either

1455[info] - IO.from converts left Either

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

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

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

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

1460[info] - IO.from converts Function0

1461[info] - IO.from converts CancelablePromise

1462[info] monix.bio.TaskConversionsSuite

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

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

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

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

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

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

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

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

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

1472[info] - IO.toAsync converts successful tasks

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

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

1475[info] - IO.toConcurrent converts successful tasks

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1496[info] - IO.fromConcurrentEffect(task.toConcurrent[CIO]) preserves cancellability

1497[info] - IO.fromReactivePublisher converts `.onNext` callbacks

1498[info] - IO.fromReactivePublisher converts `.onComplete` callbacks

1499[info] - IO.fromReactivePublisher converts `.onError` callbacks

1500[info] - IO.fromReactivePublisher protects against user errors

1501[info] - IO.fromReactivePublisher is cancelable

1502[info] - IO.fromReactivePublisher <-> Task

1503[info] monix.bio.TaskOptionsSuite

1504[info] - change options with future

1505[info] - change options with callback

1506[info] monix.bio.TaskAsyncAutoShiftJVMSuite

1507[info] - Task.fromFuture(async) should shift back to the main scheduler

1508[info] - Task.fromFuture(completed) should not shift to the main scheduler

1509[info] - Task.fromFuture(async error) should shift back to the main scheduler

1510[info] - Task.fromFuture(completed error) should not shift to the main scheduler

1511[info] - Task.deferFuture(async) should shift back to the main scheduler

1512[info] - Task.deferFuture(completed) should not shift to the main scheduler

1513[info] - Task.deferFuture(async error) should shift back to the main scheduler

1514[info] - Task.deferFuture(completed error) should not shift to the main scheduler

1515[info] - Task.deferFutureAction(async) should shift back to the main scheduler

1516[info] - Task.deferFutureAction(completed) should not shift to the main scheduler

1517[info] - Task.deferFutureAction(async error) should shift back to the main scheduler

1518[info] - Task.deferFutureAction(completed error) should not shift to the main scheduler

1519[info] - Task.fromFuture(async cancelable) should shift back to the main scheduler

1520[info] - Task.fromFuture(completed cancelable) should not shift to the main scheduler

1521[info] - Task.fromFuture(async error cancelable) should shift back to the main scheduler

1522[info] - Task.fromFuture(completed error cancelable) should not shift to the main scheduler

1523[info] - Task.deferFuture(async cancelable) should shift back to the main scheduler

1524[info] - Task.deferFuture(completed cancelable) should not shift to the main scheduler

1525[info] - Task.deferFuture(async error cancelable) should shift back to the main scheduler

1526[info] - Task.deferFuture(completed error cancelable) should not shift to the main scheduler

1527[info] - Task.deferFutureAction(async cancelable) should shift back to the main scheduler

1528[info] - Task.deferFutureAction(completed cancelable) should not shift to the main scheduler

1529[info] - Task.deferFutureAction(async error cancelable) should shift back to the main scheduler

1530[info] - Task.deferFutureAction(completed error cancelable) should not shift to the main scheduler

1531[info] - Task.async(register) should shift back if register forks

1532[info] - Task.async(register) should not shift back if register does not fork

1533[info] - Task.async(register typed) should shift back if register forks

1534[info] - Task.async(register error) should not shift back if register does not fork

1535[info] - Task.async0(register) should shift back if register forks

1536[info] - Task.async0(register) should not shift back if register does not fork

1537[info] - Task.async0(register error) should shift back if register forks

1538[info] - Task.async0(register error) should not shift back if register does not fork

1539[info] - Task.cancelable(register) should shift back if register forks

1540[info] - Task.cancelable(register) should not shift back if register does not fork

1541[info] - Task.cancelable(register error) should shift back if register forks

1542[info] - Task.cancelable(register error) should not shift back if register does not fork

1543[info] - Task.cancelable0(register) should shift back if register forks

1544[info] - Task.cancelable0(register) should not shift back if register does not fork

1545[info] - Task.cancelable0(register error) should shift back if register forks

1546[info] - Task.cancelable0(register error) should not shift back if register does not fork

1547[info] - Task.create(register) should shift back if register forks

1548[info] - Task.create(register) should not shift back if register does not fork

1549[info] - Task.create(register error) should shift back if register forks

1550[info] - Task.create(register error) should not shift back if register does not fork

1551[info] - Task.asyncF(register) should shift back if register forks

1552[info] - Task.asyncF(register) should not shift back if register does not fork

1553[info] - Task.asyncF(register error) should shift back if register forks

1554[info] - Task.asyncF(register error) should not shift back if register does not fork

1555[info] monix.bio.IOLocalJVMSuite

1556[info] - locals get transported with executeOn and shift

1557[info] - locals get transported with executeWithModel

1558[info] - locals get transported with executeWithOptions

1559[info] - IOLocal.isolate can be nested with executeWithOptions

1560[info] - local.write.executeOn(forceAsync = false) works

1561[info] - local.write.executeOn(forceAsync = true) works

1562[info] - local state is encapsulated by Task run loop with TracingScheduler

1563[info] - local state is encapsulated by Task run loop without TracingScheduler

1564[info] - local state is encapsulated by Task run loop on single thread

1565[info] - IOLocal.isolate should properly isolate during async boundaries

1566[info] - IOLocal.isolate should properly isolate during async boundaries on error

1567[info] - IOLocal.isolate should properly isolate during async boundaries on cancelation

1568[info] - IOLocal.isolate should isolate contexts from Future

1569[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation

1570[info] - Task.eval.runToFuture isolates but preserves context for Future continuation

1571[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation on a single thread

1572[info] - Task.eval.runToFuture continuations keep isolated context in longer continuations

1573[info] - Task.eval.runToFuture can isolate future continuations

1574[info] - Task.eval.runToFuture can isolate future continuations on failure

1575[info] - Task.runToFuture resulting future can be reused

1576[info] - Task.eval.runToFuture is isolated from outside changes

1577[info] monix.bio.TaskParTraverseSuite

1578[info] - IO.parTraverse should execute in parallel for async tasks

1579[info] - IO.parTraverse should onError if one of the tasks terminates in error

1580[info] - IO.parTraverse should onTerminate if one of the tasks terminates in unexpected error

1581[info] - IO.parTraverse should be canceled

1582[info] - IO.parTraverse should be stack safe for synchronous tasks

1583[info] - IO.parTraverse runAsync multiple times

1585[info] monix.bio.TaskCreateSuite

1586[info] - can use Unit as return type

1587[info] - can use Cancelable.empty as return type

1588[info] - returning Unit yields non-cancelable tasks

1589[info] - can use Cancelable as return type

1590[info] - returning Cancelable yields a cancelable task

1591[info] - can use CIO[Unit] as return type

1592[info] - returning CIO[Unit] yields a cancelable task

1593[info] - can use IO[E, Unit] as return type

1594[info] - returning IO[E, Unit] yields a cancelable task

1595[info] - throwing error when returning Unit

1596[info] - throwing error when returning Cancelable

1597[info] monix.bio.TaskConversionsKSuite

1598[info] - Task.liftTo[CIO]

1599[info] - Task.liftToAsync[IO]

1600[info] - Task.liftToConcurrent[IO]

1601[info] - Task.liftFrom[IO]

1602[info] - Task.liftFromEffect[IO]

1603[info] - Task.liftFromConcurrentEffect[IO]

1604[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite

1605[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1606[info] - CoflatMap[Task].coflatMap.coflatMap identity

1607[info] - CoflatMap[Task].coflatMap.coflatten coherence

1608[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1609[info] - CoflatMap[Task].coflatMap.covariant composition

1610[info] - CoflatMap[Task].coflatMap.covariant identity

1611[info] - CoflatMap[Task].coflatMap.invariant composition

1612[info] - CoflatMap[Task].coflatMap.invariant identity

1613[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

1614[info] - Concurrent[Task].async.ap consistent with product + map

1615[info] - Concurrent[Task].async.applicative homomorphism

1616[info] - Concurrent[Task].async.applicative identity

1617[info] - Concurrent[Task].async.applicative interchange

1618[info] - Concurrent[Task].async.applicative map

1619[info] - Concurrent[Task].async.applicative unit

1620[info] - Concurrent[Task].async.applicativeError adaptError pure

1621[info] - Concurrent[Task].async.applicativeError adaptError raise

1622[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

1623[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

1624[info] - Concurrent[Task].async.applicativeError handle

1625[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

1626[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

1627[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

1628[info] - Concurrent[Task].async.applicativeError handleError pure

1629[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

1630[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

1631[info] - Concurrent[Task].async.applicativeError handleWith

1632[info] - Concurrent[Task].async.applicativeError onError pure

1633[info] - Concurrent[Task].async.applicativeError onError raise

1634[info] - Concurrent[Task].async.applicativeError pure attempt

1635[info] - Concurrent[Task].async.applicativeError raiseError attempt

1636[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

1637[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

1638[info] - Concurrent[Task].async.apply composition

1639[info] - Concurrent[Task].async.async can be derived from asyncF

1640[info] - Concurrent[Task].async.async left is raiseError

1641[info] - Concurrent[Task].async.async right is pure

1642[info] - Concurrent[Task].async.bind suspends evaluation

1643[info] - Concurrent[Task].async.bracket is derived from bracketCase

1644[info] - Concurrent[Task].async.bracket release is called on Completed or Error

1645[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

1646[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

1647[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1648[info] - Concurrent[Task].async.covariant composition

1649[info] - Concurrent[Task].async.covariant identity

1650[info] - Concurrent[Task].async.delay constant is pure

1651[info] - Concurrent[Task].async.flatMap associativity

1652[info] - Concurrent[Task].async.flatMap consistent apply

1653[info] - Concurrent[Task].async.flatMap from tailRecM consistency

1654[info] - Concurrent[Task].async.guarantee is derived from bracket

1655[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

1656[info] - Concurrent[Task].async.invariant composition

1657[info] - Concurrent[Task].async.invariant identity

1658[info] - Concurrent[Task].async.map flatMap coherence

1659[info] - Concurrent[Task].async.map suspends evaluation

1660[info] - Concurrent[Task].async.map2/map2Eval consistency

1661[info] - Concurrent[Task].async.map2/product-map consistency

1662[info] - Concurrent[Task].async.monad left identity

1663[info] - Concurrent[Task].async.monad right identity

1664[info] - Concurrent[Task].async.monadError ensure consistency

1665[info] - Concurrent[Task].async.monadError ensureOr consistency

1666[info] - Concurrent[Task].async.monadError left zero

1667[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

1668[info] - Concurrent[Task].async.monadError rethrow attempt

1669[info] - Concurrent[Task].async.monoidal left identity

1670[info] - Concurrent[Task].async.monoidal right identity

1671[info] - Concurrent[Task].async.mproduct consistent flatMap

1672[info] - Concurrent[Task].async.never is derived from async

1673[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

1674[info] - Concurrent[Task].async.productL consistent map2

1675[info] - Concurrent[Task].async.productR consistent map2

1676[info] - Concurrent[Task].async.propagate errors through bind (async)

1677[info] - Concurrent[Task].async.propagate errors through bind (suspend)

1678[info] - Concurrent[Task].async.repeated async evaluation not memoized

1679[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

1680[info] - Concurrent[Task].async.repeated sync evaluation not memoized

1681[info] - Concurrent[Task].async.semigroupal associativity

1682[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

1683[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

1684[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

1685[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

1686[info] - Concurrent[Task].async.stack-safe on left-associated binds

1687[info] - Concurrent[Task].async.stack-safe on repeated attempts

1688[info] - Concurrent[Task].async.stack-safe on repeated maps

1689[info] - Concurrent[Task].async.stack-safe on right-associated binds

1690[info] - Concurrent[Task].async.suspend constant is pure join

1691[info] - Concurrent[Task].async.tailRecM consistent flatMap

1692[info] - Concurrent[Task].async.tailRecM stack safety

1693[info] - Concurrent[Task].async.throw in delay is raiseError

1694[info] - Concurrent[Task].async.throw in suspend is raiseError

1695[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

1696[info] - Concurrent[Task].async.unsequenced delay is no-op

1697[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

1698[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

1699[info] - ConcurrentEffect[Task].effect.applicative homomorphism

1700[info] - ConcurrentEffect[Task].effect.applicative identity

1701[info] - ConcurrentEffect[Task].effect.applicative interchange

1702[info] - ConcurrentEffect[Task].effect.applicative map

1703[info] - ConcurrentEffect[Task].effect.applicative unit

1704[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

1705[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

1706[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

1707[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

1708[info] - ConcurrentEffect[Task].effect.applicativeError handle

1709[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

1710[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

1711[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

1712[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

1713[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

1714[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

1715[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

1716[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

1717[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

1718[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

1719[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

1720[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

1721[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

1722[info] - ConcurrentEffect[Task].effect.apply composition

1723[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

1724[info] - ConcurrentEffect[Task].effect.async left is raiseError

1725[info] - ConcurrentEffect[Task].effect.async right is pure

1726[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

1727[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

1728[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

1729[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

1730[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

1731[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1732[info] - ConcurrentEffect[Task].effect.covariant composition

1733[info] - ConcurrentEffect[Task].effect.covariant identity

1734[info] - ConcurrentEffect[Task].effect.delay constant is pure

1735[info] - ConcurrentEffect[Task].effect.flatMap associativity

1736[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

1737[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

1738[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

1739[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

1740[info] - ConcurrentEffect[Task].effect.invariant composition

1741[info] - ConcurrentEffect[Task].effect.invariant identity

1742[info] - ConcurrentEffect[Task].effect.map flatMap coherence

1743[info] - ConcurrentEffect[Task].effect.map suspends evaluation

1744[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

1745[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

1746[info] - ConcurrentEffect[Task].effect.monad left identity

1747[info] - ConcurrentEffect[Task].effect.monad right identity

1748[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

1749[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

1750[info] - ConcurrentEffect[Task].effect.monadError left zero

1751[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

1752[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

1753[info] - ConcurrentEffect[Task].effect.monoidal left identity

1754[info] - ConcurrentEffect[Task].effect.monoidal right identity

1755[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

1756[info] - ConcurrentEffect[Task].effect.never is derived from async

1757[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

1758[info] - ConcurrentEffect[Task].effect.productL consistent map2

1759[info] - ConcurrentEffect[Task].effect.productR consistent map2

1760[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

1761[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

1762[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

1763[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

1764[info] - ConcurrentEffect[Task].effect.repeated callback ignored

1765[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

1766[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

1767[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

1768[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

1769[info] - ConcurrentEffect[Task].effect.semigroupal associativity

1770[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

1771[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

1772[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

1773[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

1774[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

1775[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

1776[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

1777[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

1778[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

1779[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

1780[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

1781[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

1782[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

1783[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

1784[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

1785[info] - ConcurrentEffect[Task].effect.toIO stack safety

1786[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

1787[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

1788[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

1789[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

1790[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

1791[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

1792[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

1793[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

1794[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

1795[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

1796[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

1797[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

1798[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

1799[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

1800[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

1801[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

1802[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

1803[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

1804[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

1805[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

1806[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

1807[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1808[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1809[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1810[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1811[info] - Monoid[IO[Throwable, Int]].monoid.associative

1812[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1813[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1814[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1815[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1816[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1817[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1818[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1819[info] - Monoid[IO[Throwable, Int]].monoid.is id

1820[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1821[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1822[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1823[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1824[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1825[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1826[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1827[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1828[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1829[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1830[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1831[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1832[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1833[info] monix.bio.TaskFlatMapSuite

1834[info] - runAsync flatMap loop is not cancelable if autoCancelableRunLoops=false

1835[info] - runAsync flatMap loop is cancelable if ExecutionModel permits

1836[info] - runAsync(callback) flatMap loop is cancelable if ExecutionModel permits

1837[info] - redeemWith derives flatMap

1838[info] - redeemWith derives onErrorHandleWith

1839[info] - redeem derives map . onErrorHandle

1840[info] - redeem derives onErrorHandle

1841[info] - redeemWith can recover

1842[info] - redeem can recover

1843[info] - >> is stack safe for infinite loops

1844[info] - flatMapLoop enables loops

1845[info] monix.bio.TaskEvalOnceSuite

1846[info] - IO.evalOnce should protect against user code errors

1847[info] - IO.evalOnce.flatMap should be equivalent with Task.evalOnce

1848[info] - IO.evalOnce.flatMap should protect against user code

1849[info] - IO.evalOnce.map should work

1850[info] - IO.evalOnce.flatMap should be tail recursive

1851[info] - IO.EvalOnce.runAsync override

1852[info] - IO.evalOnce.materialize should work for success

1853[info] - IO.evalOnce.materialize should work for failure

1854[info] monix.bio.TaskAsyncSuite

1855[info] - IO.never should never complete

1856[info] - IO.async should execute

1857[info] - IO.async should signal errors in register

1858[info] - IO.async should be stack safe

1859[info] - IO.async works for immediate successful value

1860[info] - IO.async works for immediate error

1861[info] - IO.async works for immediate terminate error

1862[info] - IO.async is memory safe in flatMap loops

1863[info] - IO.async0 works for immediate successful value

1864[info] - IO.async0 works for async successful value

1865[info] - IO.async0 works for async error

1866[info] - IO.async0 works for async terminate error

1867[info] - IO.async0 is memory safe in synchronous flatMap loops

1868[info] - IO.async0 is memory safe in async flatMap loops

1869[info] monix.bio.TaskNowSuite

1870[info] - IO.now should work synchronously

1871[info] - IO.now.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

1872[info] - IO.now.runAsync(callback) should work synchronously

1873[info] - IO.now.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

1874[info] - IO.raiseError should work synchronously

1875[info] - IO.terminate should work synchronously

1876[info] - IO.raiseError.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

1877[info] - IO.raiseError.runAsync(callback) should work synchronously

1878[info] - IO.raiseError.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

1879[info] - IO.now.map should work

1880[info] - IO.raiseError.map should be the same as IO.raiseError

1881[info] - IO.raiseError.flatMap should be the same as IO.flatMap

1882[info] - IO.raiseError.flatMap should be protected

1883[info] - IO.now.flatMap should protect against user code

1884[info] - IO.now.flatMap should be tail recursive

1885[info] - IO.now should not be cancelable

1886[info] - IO.raiseError should not be cancelable

1887[info] - IO.terminate should not be cancelable

1888[info] - IO.now.runSyncStep

1889[info] - IO.raiseError.runSyncStep

1890[info] monix.bio.TaskStartSuite

1891[info] - task.start.flatMap(_.join) <-> task

1892[info] - task.start.flatMap(id) is cancelable, but the source is memoized

1893[info] - task.start is stack safe

1894[info] - task.start shares Local.Context with fibers

1895[info] - task.start is stack safe

1896[info] - task.start executes asynchronously

1897[info] monix.bio.TaskGuaranteeSuite

1898[info] - finalizer is evaluated on success

1899[info] - finalizer is evaluated on error

1900[info] - finalizer is evaluated on terminal error

1901[info] - if finalizer throws, report finalizer error and signal use error

1902[info] - finalizer is evaluated on cancelation (1)

1903[info] - finalizer is evaluated on cancellation (2)

1904[info] - stack-safety (1)

1905[info] - stack-safety (2)

1906[info] - stack-safety (3)

1907[info] monix.bio.IOFromFutureEitherSuite

1908[info] - IO.fromFutureEither should return success channel for Right

1909[info] - IO.fromFutureEither should return checked failure channel for Left

1910[info] - IO.fromFutureEither should return unchecked failure channel for a failed Future

1911[info] - IO.fromFutureEither(cancelable) should work for Right synchronous results onSuccess

1912[info] - IO.fromFutureEither(cancelable) should work for Left synchronous results onSuccess

1913[info] - IO.fromFutureEither(cancelable) should work for synchronous results onFailure

1914[info] - IO.fromFutureEither(cancelable) should be short-circuited for Right onSuccess

1915[info] - IO.fromFutureEither(cancelable) should be short-circuited for Left onSuccess

1916[info] - IO.fromFutureEither(cancelable) should be short-circuited onError

1917[info] - IO.fromFutureEither(cancelable) should work onSuccess

1918[info] - IO.fromFutureEither(cancelable) should work onError

1919[info] - IO.fromFutureEither(cancelable) should be cancelable

1920[info] - IO.fromFutureEither should be stack safe

1921[info] monix.bio.TaskAsyncBoundarySuite

1922[info] - IO.asyncBoundary should work

1923[info] - IO.asyncBoundary(other) should work

1924[info] - IO.asyncBoundary should preserve locals

1925[info] - IO.asyncBoundary(scheduler) should preserve locals

1926[info] - IO.asyncBoundary is stack safe in flatMap loops, test 1

1927[info] - IO.asyncBoundary is stack safe in flatMap loops, test 2

1928[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite

1929[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1930[info] - CoflatMap[Task].coflatMap.coflatMap identity

1931[info] - CoflatMap[Task].coflatMap.coflatten coherence

1932[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1933[info] - CoflatMap[Task].coflatMap.covariant composition

1934[info] - CoflatMap[Task].coflatMap.covariant identity

1935[info] - CoflatMap[Task].coflatMap.invariant composition

1936[info] - CoflatMap[Task].coflatMap.invariant identity

1937[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1938[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1939[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1940[info] - Concurrent[Task].concurrent.ap consistent with product + map

1941[info] - Concurrent[Task].concurrent.applicative homomorphism

1942[info] - Concurrent[Task].concurrent.applicative identity

1943[info] - Concurrent[Task].concurrent.applicative interchange

1944[info] - Concurrent[Task].concurrent.applicative map

1945[info] - Concurrent[Task].concurrent.applicative unit

1946[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1947[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1948[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1949[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1950[info] - Concurrent[Task].concurrent.applicativeError handle

1951[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1952[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1953[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1954[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1955[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

1956[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

1957[info] - Concurrent[Task].concurrent.applicativeError handleWith

1958[info] - Concurrent[Task].concurrent.applicativeError onError pure

1959[info] - Concurrent[Task].concurrent.applicativeError onError raise

1960[info] - Concurrent[Task].concurrent.applicativeError pure attempt

1961[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

1962[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

1963[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

1964[info] - Concurrent[Task].concurrent.apply composition

1965[info] - Concurrent[Task].concurrent.async can be derived from asyncF

1966[info] - Concurrent[Task].concurrent.async cancelable coherence

1967[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

1968[info] - Concurrent[Task].concurrent.async left is raiseError

1969[info] - Concurrent[Task].concurrent.async right is pure

1970[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

1971[info] - Concurrent[Task].concurrent.bind suspends evaluation

1972[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

1973[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

1974[info] - Concurrent[Task].concurrent.bracket release is called on cancel

1975[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

1976[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

1977[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1978[info] - Concurrent[Task].concurrent.covariant composition

1979[info] - Concurrent[Task].concurrent.covariant identity

1980[info] - Concurrent[Task].concurrent.delay constant is pure

1981[info] - Concurrent[Task].concurrent.flatMap associativity

1982[info] - Concurrent[Task].concurrent.flatMap consistent apply

1983[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

1984[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

1985[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

1986[info] - Concurrent[Task].concurrent.invariant composition

1987[info] - Concurrent[Task].concurrent.invariant identity

1988[info] - Concurrent[Task].concurrent.join is idempotent

1989[info] - Concurrent[Task].concurrent.map flatMap coherence

1990[info] - Concurrent[Task].concurrent.map suspends evaluation

1991[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

1992[info] - Concurrent[Task].concurrent.map2/product-map consistency

1993[info] - Concurrent[Task].concurrent.monad left identity

1994[info] - Concurrent[Task].concurrent.monad right identity

1995[info] - Concurrent[Task].concurrent.monadError ensure consistency

1996[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

1997[info] - Concurrent[Task].concurrent.monadError left zero

1998[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

1999[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2000[info] - Concurrent[Task].concurrent.monoidal left identity

2001[info] - Concurrent[Task].concurrent.monoidal right identity

2002[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2003[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2004[info] - Concurrent[Task].concurrent.productL consistent map2

2005[info] - Concurrent[Task].concurrent.productR consistent map2

2006[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2007[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2008[info] - Concurrent[Task].concurrent.race cancels both

2009[info] - Concurrent[Task].concurrent.race cancels loser

2010[info] - Concurrent[Task].concurrent.race mirrors left winner

2011[info] - Concurrent[Task].concurrent.race mirrors right winner

2012[info] - Concurrent[Task].concurrent.racePair can join left

2013[info] - Concurrent[Task].concurrent.racePair can join right

2014[info] - Concurrent[Task].concurrent.racePair cancels both

2015[info] - Concurrent[Task].concurrent.racePair cancels loser

2016[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2017[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2018[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2019[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2020[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2021[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2022[info] - Concurrent[Task].concurrent.semigroupal associativity

2023[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2024[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2025[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2026[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2027[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2028[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2029[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2030[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2031[info] - Concurrent[Task].concurrent.start then join is identity

2032[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2033[info] - Concurrent[Task].concurrent.suspend constant is pure join

2034[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2035[info] - Concurrent[Task].concurrent.tailRecM stack safety

2036[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2037[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2038[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2039[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2040[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2041[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2042[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2043[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2044[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2045[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2046[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2047[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2048[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2049[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2050[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2051[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2052[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2053[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2054[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2055[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2056[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2057[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2058[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2059[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2060[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2061[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2062[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2063[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2064[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2065[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2066[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2067[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2068[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2069[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2070[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2071[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2072[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2073[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2074[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2075[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2076[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2077[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2078[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2079[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2080[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2081[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2082[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2083[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2084[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2085[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2086[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2087[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2088[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2089[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2090[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2091[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2092[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2093[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2094[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2095[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2096[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2097[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2098[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2099[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2100[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2101[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2102[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2103[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2104[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2105[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2106[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2107[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2108[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2109[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2110[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2111[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2112[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2113[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2114[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2115[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2116[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2117[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2118[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2119[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2120[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2121[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2122[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2123[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2124[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2125[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2126[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2127[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2128[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2129[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2130[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2131[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2132[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2133[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2134[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2135[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2136[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2137[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2138[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2139[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2140[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2141[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2142[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2143[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2144[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2145[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2146[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2147[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2148[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2149[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2150[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2151[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2152[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2153[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2154[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2155[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2156[info] - Applicative[Task.Par].applicative.ap consistent with product + map

2157[info] - Applicative[Task.Par].applicative.applicative homomorphism

2158[info] - Applicative[Task.Par].applicative.applicative identity

2159[info] - Applicative[Task.Par].applicative.applicative interchange

2160[info] - Applicative[Task.Par].applicative.applicative map

2161[info] - Applicative[Task.Par].applicative.applicative unit

2162[info] - Applicative[Task.Par].applicative.apply composition

2163[info] - Applicative[Task.Par].applicative.covariant composition

2164[info] - Applicative[Task.Par].applicative.covariant identity

2165[info] - Applicative[Task.Par].applicative.invariant composition

2166[info] - Applicative[Task.Par].applicative.invariant identity

2167[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

2168[info] - Applicative[Task.Par].applicative.map2/product-map consistency

2169[info] - Applicative[Task.Par].applicative.monoidal left identity

2170[info] - Applicative[Task.Par].applicative.monoidal right identity

2171[info] - Applicative[Task.Par].applicative.productL consistent map2

2172[info] - Applicative[Task.Par].applicative.productR consistent map2

2173[info] - Applicative[Task.Par].applicative.semigroupal associativity

2174[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2175[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2176[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2177[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2178[info] - Monoid[IO[Throwable, Int]].monoid.associative

2179[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2180[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2181[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2182[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2183[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2184[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2185[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2186[info] - Monoid[IO[Throwable, Int]].monoid.is id

2187[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2188[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2189[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2190[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2191[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2192[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2193[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2194[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2195[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2196[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2197[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2198[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2199[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2200[info] monix.bio.TaskClockTimerAndContextShiftSuite

2201[info] - IO.clock is implicit

2202[info] - IO.clock.monotonic

2203[info] - IO.clock.realTime

2204[info] - IO.clock(s2).monotonic

2205[info] - IO.clock(s).realTime

2206[info] - IO.timer is implicit

2207[info] - IO.timer

2208[info] - IO.timer(s)

2209[info] - IO.timer(s).clock

2210[info] - IO.contextShift is implicit

2211[info] - IO.contextShift.shift

2212[info] - IO.contextShift.evalOn(s2)

2213[info] - IO.contextShift.evalOn(s2) failure

2214[info] - IO.contextShift.evalOn(s2) fatal failure

2215[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries

2216[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction

2217[info] - IO.contextShift(s).shift

2218[info] - IO.contextShift(s).evalOn(s2)

2219[info] - IO.contextShift(s).evalOn(s2) failure

2220[info] - IO.contextShift(s).evalOn(s2) fatal failure

2221[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries

2222[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction

2223[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite

2224[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2225[info] - CoflatMap[Task].coflatMap.coflatMap identity

2226[info] - CoflatMap[Task].coflatMap.coflatten coherence

2227[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2228[info] - CoflatMap[Task].coflatMap.covariant composition

2229[info] - CoflatMap[Task].coflatMap.covariant identity

2230[info] - CoflatMap[Task].coflatMap.invariant composition

2231[info] - CoflatMap[Task].coflatMap.invariant identity

2232[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2233[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2234[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2235[info] - Concurrent[Task].concurrent.ap consistent with product + map

2236[info] - Concurrent[Task].concurrent.applicative homomorphism

2237[info] - Concurrent[Task].concurrent.applicative identity

2238[info] - Concurrent[Task].concurrent.applicative interchange

2239[info] - Concurrent[Task].concurrent.applicative map

2240[info] - Concurrent[Task].concurrent.applicative unit

2241[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2242[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2243[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2244[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2245[info] - Concurrent[Task].concurrent.applicativeError handle

2246[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2247[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2248[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2249[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2250[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2251[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2252[info] - Concurrent[Task].concurrent.applicativeError handleWith

2253[info] - Concurrent[Task].concurrent.applicativeError onError pure

2254[info] - Concurrent[Task].concurrent.applicativeError onError raise

2255[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2256[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2257[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2258[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2259[info] - Concurrent[Task].concurrent.apply composition

2260[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2261[info] - Concurrent[Task].concurrent.async cancelable coherence

2262[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2263[info] - Concurrent[Task].concurrent.async left is raiseError

2264[info] - Concurrent[Task].concurrent.async right is pure

2265[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2266[info] - Concurrent[Task].concurrent.bind suspends evaluation

2267[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2268[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2269[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2270[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2271[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2272[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2273[info] - Concurrent[Task].concurrent.covariant composition

2274[info] - Concurrent[Task].concurrent.covariant identity

2275[info] - Concurrent[Task].concurrent.delay constant is pure

2276[info] - Concurrent[Task].concurrent.flatMap associativity

2277[info] - Concurrent[Task].concurrent.flatMap consistent apply

2278[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2279[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2280[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2281[info] - Concurrent[Task].concurrent.invariant composition

2282[info] - Concurrent[Task].concurrent.invariant identity

2283[info] - Concurrent[Task].concurrent.join is idempotent

2284[info] - Concurrent[Task].concurrent.map flatMap coherence

2285[info] - Concurrent[Task].concurrent.map suspends evaluation

2286[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2287[info] - Concurrent[Task].concurrent.map2/product-map consistency

2288[info] - Concurrent[Task].concurrent.monad left identity

2289[info] - Concurrent[Task].concurrent.monad right identity

2290[info] - Concurrent[Task].concurrent.monadError ensure consistency

2291[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2292[info] - Concurrent[Task].concurrent.monadError left zero

2293[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2294[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2295[info] - Concurrent[Task].concurrent.monoidal left identity

2296[info] - Concurrent[Task].concurrent.monoidal right identity

2297[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2298[info] - Concurrent[Task].concurrent.never is derived from async

2299[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2300[info] - Concurrent[Task].concurrent.productL consistent map2

2301[info] - Concurrent[Task].concurrent.productR consistent map2

2302[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2303[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2304[info] - Concurrent[Task].concurrent.race cancels both

2305[info] - Concurrent[Task].concurrent.race cancels loser

2306[info] - Concurrent[Task].concurrent.race mirrors left winner

2307[info] - Concurrent[Task].concurrent.race mirrors right winner

2308[info] - Concurrent[Task].concurrent.racePair can join left

2309[info] - Concurrent[Task].concurrent.racePair can join right

2310[info] - Concurrent[Task].concurrent.racePair cancels both

2311[info] - Concurrent[Task].concurrent.racePair cancels loser

2312[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2313[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2314[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2315[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2316[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2317[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2318[info] - Concurrent[Task].concurrent.semigroupal associativity

2319[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2320[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2321[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2322[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2323[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2324[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2325[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2326[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2327[info] - Concurrent[Task].concurrent.start then join is identity

2328[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2329[info] - Concurrent[Task].concurrent.suspend constant is pure join

2330[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2331[info] - Concurrent[Task].concurrent.tailRecM stack safety

2332[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2333[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2334[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2335[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2336[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2337[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2338[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2339[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2340[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2341[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2342[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2343[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2344[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2345[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2346[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2347[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2348[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2349[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2350[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2351[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2352[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2353[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2354[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2355[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2356[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2357[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2358[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2359[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2360[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2361[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2362[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2363[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2364[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2365[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2366[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2367[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2368[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2369[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2370[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2371[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2372[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2373[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2374[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2375[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2376[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2377[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2378[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2379[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2380[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2381[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2382[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2383[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2384[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2385[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2386[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2387[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2388[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2389[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2390[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2391[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2392[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2393[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2394[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2395[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2396[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2397[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2398[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2399[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2400[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2401[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2402[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2403[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2404[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2405[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2406[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2407[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2408[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2409[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2410[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2411[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2412[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2413[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2414[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2415[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2416[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2417[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2418[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2419[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2420[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2421[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2422[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2423[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2424[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2425[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2426[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2427[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2428[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2429[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2430[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2431[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2432[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2433[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2434[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2435[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2436[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2437[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2438[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2439[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2440[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2441[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2442[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2443[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2444[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2445[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2446[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2447[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2448[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2449[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2450[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2451[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2452[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2453[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2454[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2455[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2456[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2457[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2458[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2459[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2460[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2461[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2462[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2463[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2464[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2465[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2466[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2467[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2468[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2469[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2470[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2471[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2472[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2473[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2474[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2475[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2476[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2477[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2478[info] - Monoid[IO[String, Int]].monoid.associative

2479[info] - Monoid[IO[String, Int]].monoid.collect0

2480[info] - Monoid[IO[String, Int]].monoid.combine all

2481[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2482[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2483[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2484[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2485[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2486[info] - Monoid[IO[String, Int]].monoid.is id

2487[info] - Monoid[IO[String, Int]].monoid.left identity

2488[info] - Monoid[IO[String, Int]].monoid.repeat0

2489[info] - Monoid[IO[String, Int]].monoid.repeat1

2490[info] - Monoid[IO[String, Int]].monoid.repeat2

2491[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2492[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2493[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2494[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2495[info] - Monoid[IO[String, Int]].monoid.right identity

2496[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2497[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2498[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2499[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2500[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2501[info] monix.bio.TaskParSequenceUnorderedSuite

2502[info] - IO.parSequenceUnordered should execute in parallel

2503[info] - IO.parSequenceUnordered should onError if one of the tasks terminates in error

2504[info] - IO.parSequenceUnordered should onTerminate if one of the tasks terminates in a fatal error

2505[info] - IO.parSequenceUnordered should be canceled

2506[info] - IO.parSequenceUnordered should run over an iterable

2507[info] - IO.parSequenceUnordered should be stack-safe on handling many tasks

2508[info] - IO.parSequenceUnordered should be stack safe on success

2509[info] - IO.parSequenceUnordered should log errors if multiple errors happen

2510[info] - IO.parSequenceUnordered should log terminal errors if multiple errors happen

2511[info] - IO.parSequenceUnordered runAsync multiple times

2512[info] monix.bio.TypeClassLawsForTaskSuite

2513[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2514[info] - CoflatMap[Task].coflatMap.coflatMap identity

2515[info] - CoflatMap[Task].coflatMap.coflatten coherence

2516[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2517[info] - CoflatMap[Task].coflatMap.covariant composition

2518[info] - CoflatMap[Task].coflatMap.covariant identity

2519[info] - CoflatMap[Task].coflatMap.invariant composition

2520[info] - CoflatMap[Task].coflatMap.invariant identity

2521[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2522[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2523[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2524[info] - Concurrent[Task].concurrent.ap consistent with product + map

2525[info] - Concurrent[Task].concurrent.applicative homomorphism

2526[info] - Concurrent[Task].concurrent.applicative identity

2527[info] - Concurrent[Task].concurrent.applicative interchange

2528[info] - Concurrent[Task].concurrent.applicative map

2529[info] - Concurrent[Task].concurrent.applicative unit

2530[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2531[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2532[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2533[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2534[info] - Concurrent[Task].concurrent.applicativeError handle

2535[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2536[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2537[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2538[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2539[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2540[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2541[info] - Concurrent[Task].concurrent.applicativeError handleWith

2542[info] - Concurrent[Task].concurrent.applicativeError onError pure

2543[info] - Concurrent[Task].concurrent.applicativeError onError raise

2544[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2545[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2546[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2547[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2548[info] - Concurrent[Task].concurrent.apply composition

2549[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2550[info] - Concurrent[Task].concurrent.async cancelable coherence

2551[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2552[info] - Concurrent[Task].concurrent.async left is raiseError

2553[info] - Concurrent[Task].concurrent.async right is pure

2554[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2555[info] - Concurrent[Task].concurrent.bind suspends evaluation

2556[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2557[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2558[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2559[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2560[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2561[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2562[info] - Concurrent[Task].concurrent.covariant composition

2563[info] - Concurrent[Task].concurrent.covariant identity

2564[info] - Concurrent[Task].concurrent.delay constant is pure

2565[info] - Concurrent[Task].concurrent.flatMap associativity

2566[info] - Concurrent[Task].concurrent.flatMap consistent apply

2567[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2568[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2569[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2570[info] - Concurrent[Task].concurrent.invariant composition

2571[info] - Concurrent[Task].concurrent.invariant identity

2572[info] - Concurrent[Task].concurrent.join is idempotent

2573[info] - Concurrent[Task].concurrent.map flatMap coherence

2574[info] - Concurrent[Task].concurrent.map suspends evaluation

2575[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2576[info] - Concurrent[Task].concurrent.map2/product-map consistency

2577[info] - Concurrent[Task].concurrent.monad left identity

2578[info] - Concurrent[Task].concurrent.monad right identity

2579[info] - Concurrent[Task].concurrent.monadError ensure consistency

2580[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2581[info] - Concurrent[Task].concurrent.monadError left zero

2582[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2583[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2584[info] - Concurrent[Task].concurrent.monoidal left identity

2585[info] - Concurrent[Task].concurrent.monoidal right identity

2586[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2587[info] - Concurrent[Task].concurrent.never is derived from async

2588[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2589[info] - Concurrent[Task].concurrent.productL consistent map2

2590[info] - Concurrent[Task].concurrent.productR consistent map2

2591[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2592[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2593[info] - Concurrent[Task].concurrent.race cancels both

2594[info] - Concurrent[Task].concurrent.race cancels loser

2595[info] - Concurrent[Task].concurrent.race mirrors left winner

2596[info] - Concurrent[Task].concurrent.race mirrors right winner

2597[info] - Concurrent[Task].concurrent.racePair can join left

2598[info] - Concurrent[Task].concurrent.racePair can join right

2599[info] - Concurrent[Task].concurrent.racePair cancels both

2600[info] - Concurrent[Task].concurrent.racePair cancels loser

2601[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2602[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2603[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2604[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2605[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2606[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2607[info] - Concurrent[Task].concurrent.semigroupal associativity

2608[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2609[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2610[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2611[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2612[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2613[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2614[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2615[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2616[info] - Concurrent[Task].concurrent.start then join is identity

2617[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2618[info] - Concurrent[Task].concurrent.suspend constant is pure join

2619[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2620[info] - Concurrent[Task].concurrent.tailRecM stack safety

2621[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2622[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2623[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2624[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2625[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2626[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2627[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2628[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2629[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2630[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2631[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2632[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2633[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2634[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2635[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2636[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2637[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2638[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2639[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2640[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2641[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2642[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2643[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2644[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2645[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2646[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2647[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2648[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2649[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2650[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2651[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2652[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2653[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2654[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2655[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2656[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2657[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2658[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2659[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2660[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2661[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2662[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2663[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2664[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2665[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2666[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2667[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2668[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2669[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2670[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2671[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2672[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2673[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2674[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2675[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2676[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2677[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2678[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2679[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2680[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2681[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2682[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2683[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2684[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2685[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2686[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2687[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2688[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2689[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2690[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2691[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2692[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2693[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2694[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2695[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2696[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2697[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2698[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2699[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2700[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2701[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2702[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2703[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2704[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2705[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2706[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2707[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2708[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2709[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2710[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2711[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2712[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2713[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2714[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2715[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2716[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2717[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2718[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2719[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2720[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2721[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2722[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2723[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2724[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2725[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2726[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2727[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2728[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2729[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2730[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2731[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2732[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2733[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2734[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2735[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2736[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2737[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2738[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2739[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2740[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2741[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2742[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2743[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2744[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2745[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2746[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2747[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2748[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2749[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2750[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2751[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2752[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2753[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2754[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2755[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2756[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2757[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2758[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2759[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2760[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2761[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2762[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2763[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2764[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2765[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2766[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2767[info] - Monoid[IO[String, Int]].monoid.associative

2768[info] - Monoid[IO[String, Int]].monoid.collect0

2769[info] - Monoid[IO[String, Int]].monoid.combine all

2770[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2771[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2772[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2773[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2774[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2775[info] - Monoid[IO[String, Int]].monoid.is id

2776[info] - Monoid[IO[String, Int]].monoid.left identity

2777[info] - Monoid[IO[String, Int]].monoid.repeat0

2778[info] - Monoid[IO[String, Int]].monoid.repeat1

2779[info] - Monoid[IO[String, Int]].monoid.repeat2

2780[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2781[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2782[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2783[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2784[info] - Monoid[IO[String, Int]].monoid.right identity

2785[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2786[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2787[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2788[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2789[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2790[info] monix.bio.TaskMiscSuite

2791[info] - IO.attempt should succeed

2792[info] - IO.raiseError.attempt should expose error

2793[info] - IO.mapError should map error

2794[info] - IO.terminate.attempt should not expose error

2795[info] - IO.tapError should not alter original successful value

2796[info] - IO.tapError should not alter original error value

2797[info] - IO.tapError should not alter original terminal error

2798[info] - IO.failed should expose error

2799[info] - IO.failed should fail for successful values

2800[info] - IO.map protects against user code

2801[info] - IO.forever

2802[info] - IO.restartUntil should keep retrying IO until predicate succeeds

2803[info] - IO.toReactivePublisher should convert tasks with no errors

2804[info] - IO.toReactivePublisher should convert tasks with typed errors

2805[info] - IO.toReactivePublisher should convert tasks with terminal errors

2806[info] - IO.toReactivePublisher should be cancelable

2807[info] - IO.toReactivePublisher should throw errors on invalid requests

2808[info] - IO.pure is an alias of now

2809[info] - IO.now.runAsync with Try-based callback

2810[info] - Task.error.runAsync with Try-based callback

2811[info] - Task.terminate.runAsync with Try-based callback

2812[info] - task.executeAsync.runAsync with Try-based callback for success

2813[info] - task.executeAsync.runAsync with Try-based callback for error

2814[info] - task.executeAsync.runAsync with Try-based callback for terminal error

2815[info] - task.executeWithOptions protects against user error

2816[info] monix.bio.TaskDeferActionSuite

2817[info] - IO.deferAction works

2818[info] - IO.deferAction works for failed tasks

2819[info] - IO.deferAction protects against user error

2820[info] - IO.deferAction should properly cast errors

2821[info] - IO.deferAction is stack safe

2822[info] - IO.deferAction(local.write) works

2823[info] monix.bio.FiberDoctest

2824[info] - Fiber.scala:22: Fiber

2825Hello World!

2826[info] monix.bio.TaskExecuteWithModelSuite

2827[info] - executeWithModel works

2828[info] - local.write.executeWithModel(AlwaysAsyncExecution) works

2829[info] - local.write.executeWithModel(SynchronousExecution) works

2830[info] - executeWithModel is stack safe in flatMap loops

2831Cancelling!

2832Received: $value

2833Hello!

2834Hello!

2835Success: 42

2836[info] monix.bio.IODoctest

2837[info] - IO.scala:52: IO

2838[info] - IO.scala:474: runToFuture

2839[info] - IO.scala:541: runToFutureOpt

2840[info] - IO.scala:586: runAsync

2841[info] - IO.scala:661: runAsyncOpt

2842[info] - IO.scala:716: runAsyncF

2843[info] - IO.scala:821: runAsyncAndForget

2844[info] - IO.scala:874: runAsyncUncancelable

2845[info] - IO.scala:947: runSyncStep

2846[info] - IO.scala:1011: runSyncUnsafe

2847[info] - IO.scala:1116: memoize

2848[info] - IO.scala:1155: memoizeOnSuccess

2849[info] - IO.scala:1213: >>

2850[info] - IO.scala:1226: *>

2851[info] - IO.scala:1242: <*

2852[info] - IO.scala:1257: asyncBoundary

2853[info] - IO.scala:1306: asyncBoundary

2854[info] - IO.scala:1337: bracket

2855[info] - IO.scala:1525: delayExecution

2856[info] - IO.scala:1554: delayResult

2857[info] - IO.scala:1595: executeOn

2858[info] - IO.scala:1730: executeAsync

2859[info] - IO.scala:1756: executeWithModel

2860[info] - IO.scala:1774: executeWithOptions

2861[info] - IO.scala:1801: flip

2862[info] - IO.scala:1831: flipWith

2863[info] - IO.scala:1879: flatMapLoop

2864[info] - IO.scala:1937: loopForever

2865[info] - IO.scala:2008: onCancelRaiseError

2866[info] - IO.scala:2062: mapErrorPartialWith

2867[info] - IO.scala:2113: tapError

2868[info] - IO.scala:2147: onErrorRestartIf

2869[info] - IO.scala:2167: onErrorRestartLoop

2870[info] - IO.scala:2242: mapError

2871[info] - IO.scala:2261: mapErrorPartial

2872[info] - IO.scala:2296: start

2873[info] - IO.scala:2324: to

2874[info] - IO.scala:2366: toConcurrent

2875[info] - IO.scala:2412: toAsync

2876[info] - IO.scala:2536: uncancelable

2877[info] - IO.scala:2559: timed

2878[info] - IO.scala:2608: timeoutToL

2879[info] - IO.scala:2663: hideErrors

2880[info] - IO.scala:2684: hideErrorsWith

2881[info] - IO.scala:2740: absorb

2882[info] - IO.scala:2758: absorbWith

2883[info] - IO.scala:2782: IO

2884[info] - IO.scala:2843: apply

2885[info] - IO.scala:2905: deferAction

2886[info] - IO.scala:2932: deferFuture

2887[info] - IO.scala:2945: deferFutureAction

2888[info] - IO.scala:3082: fromConcurrentEffect

2889[info] - IO.scala:3119: fromEffect

2890[info] - IO.scala:3149: fromOption

2891[info] - IO.scala:3165: fromOption

2892[info] - IO.scala:3185: fromOptionEval

2893[info] - IO.scala:3243: async

2894[info] - IO.scala:3303: async0

2895[info] - IO.scala:3399: cancelable

2896[info] - IO.scala:3479: cancelable0

2897[info] - IO.scala:3581: cancelBoundary

2898[info] - IO.scala:3617: create

2899[info] - IO.scala:3724: race

2900[info] - IO.scala:3757: raceMany

2901[info] - IO.scala:3778: racePair

2902[info] - IO.scala:3861: sleep

2903[info] - IO.scala:3952: parSequence

2904[info] - IO.scala:4011: parSequenceN

2905[info] - IO.scala:4042: parTraverseN

2906[info] - IO.scala:4079: parSequenceUnordered

2907[info] - IO.scala:4127: mapBoth

2908[info] - IO.scala:4146: map2

2909[info] - IO.scala:4175: map3

2910[info] - IO.scala:4205: map4

2911[info] - IO.scala:4238: map5

2912[info] - IO.scala:4276: map6

2913[info] - IO.scala:4316: parMap2

2914[info] - IO.scala:4351: parMap3

2915[info] - IO.scala:4389: parMap4

2916[info] - IO.scala:4430: parMap5

2917[info] - IO.scala:4476: parMap6

2918[info] - IO.scala:4562: liftTo

2919[info] - IO.scala:4622: liftFrom

2920[info] - IO.scala:5282: catsParallel

2921[info] monix.bio.TaskParSequenceSuite

2922[info] - IO.parSequence should execute in parallel for async tasks

2923[info] - IO.parSequence should onError if one of the tasks terminates in error

2924[info] - IO.parSequence should onTerminate if one of the tasks terminates in a fatal error

2925[info] - IO.parSequence should be canceled

2926[info] - IO.parSequence should be stack safe for synchronous tasks

2927[info] - IO.parSequence runAsync multiple times

2928[info] - IO.parSequence should log errors if multiple errors happen

2929[info] - IO.parSequence should log terminal errors if multiple errors happen

2930[info] monix.bio.TaskParTraverseNSuite

2931[info] - IO.parTraverseN allows fully sequential execution

2932[info] - IO.parTraverseN allows fully concurrent execution

2933[info] - IO.parTraverseN allows partially concurrent execution

2934[info] - IO.parTraverseN returns an error when fully sequential execution fails in a typed way

2935[info] - IO.parTraverseN returns an error when fully sequential execution fails in a terminal way

2936[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a typed way

2937[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a terminal way

2938[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a typed way

2939[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a terminal way

2941[info] - IO.parTraverseN should be cancelable

2942[info] - IO.parTraverseN should be stack safe for synchronous tasks with low parallelism

2943[info] - IO.parTraverseN should be stack safe for asynchronous tasks with low parallelism

2944[info] - IO.parTraverseN should be stack safe for synchronous tasks with high parallelism

2945[info] - IO.parTraverseN should be stack safe for asynchronous tasks with high parallelism

2946[info] - IO.parTraverseN allows running the same effect multiple times

2947[info] - IO.parTraverseN allows reusing a memoized effect multiple times

2948Executing...

2949Received: $str

2950Executing...

2951Executing...

2952Finished via exit code: $exitCode

2953Resources were released!

2954Executing...

2955Received: $str

2957************************

2958Build summary:

2959[{

2960 "module": "monix-bio",

2961 "compile": {"status": "ok", "tookMs": 19232, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2962 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2963 "test-compile": {"status": "ok", "tookMs": 38496, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2964 "test": {"status": "ok", "tookMs": 32077, "passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607, "byFramework": [{"framework": "unknown", "stats": {"passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607}}]},

2965 "publish": {"status": "skipped", "tookMs": 0},

2966 "metadata": {

2967 "crossScalaVersions": ["2.12.13", "2.13.5", "3.0.0"]

2968}

2969}]

2970************************

2971[success] Total time: 95 s (0:01:35.0), completed Dec 31, 2025, 9:23:39 PM

2972[0JChecking patch project/plugins.sbt...

2973Checking patch project/build.properties...

2974Checking patch build.sbt...

2975Applied patch project/plugins.sbt cleanly.

2976Applied patch project/build.properties cleanly.

2977Applied patch build.sbt cleanly.