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-RC3

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-RC3

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-RC3

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-RC3

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-RC3"

60"++3.8.0-RC3 -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-RC3 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}""" io.monix%monix-bio"

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

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

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

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

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

74[info] Compilation completed in 8.683s.

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-RC3

195OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC3 in tracingTests/crossScalaVersions

196OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC3 in benchmarks/crossScalaVersions

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

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

199OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC3 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-RC3 on 5 projects.

202[info] Switching Scala version on:

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

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

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

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

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

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 4, 2025, 3:48:36 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-RC3/classes ...

246[info] done compiling

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

250[info] done compiling

251[info] monix.bio.TaskSuspendSuite

252[info] - IO.suspend should suspend evaluation

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

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

255[info] monix.bio.TaskSequenceSuite

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

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

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

259[info] - IO.sequence should be canceled

260[info] monix.bio.IOMapNSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

281[info] monix.bio.TaskEvalAlwaysSuite

282[info] - IO.eval should work synchronously

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

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

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

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

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

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

289[info] - IO.eval.coeval

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

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

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

293[info] monix.bio.TaskEvalOnceSuite

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

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

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

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

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

299[info] - IO.EvalOnce.runAsync override

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

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

302[info] monix.bio.TaskStartSuite

303[info] - task.start.flatMap(_.join) <-> task

304[info] - task.start.flatMap(id) is cancelable, but the source is memoized

305[info] - task.start is stack safe

306[info] - task.start shares Local.Context with fibers

307[info] - task.start is stack safe

308[info] - task.start executes asynchronously

309[info] monix.bio.TaskBimapSuite

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

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

312value1: 0

313value2: 100

314value3: 400

315value4: 100

316value5: 0

317[info] monix.bio.IOLocalDoctest

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

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

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

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

322[info] monix.bio.TaskFlatMapSuite

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

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

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

326[info] - redeemWith derives flatMap

327[info] - redeemWith derives onErrorHandleWith

328[info] - redeem derives map . onErrorHandle

329[info] - redeem derives onErrorHandle

330[info] - redeemWith can recover

331[info] - redeem can recover

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

333[info] - flatMapLoop enables loops

334[info] monix.bio.TaskMapBothSuite

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

336[info] - sum two async tasks

337[info] - sum two synchronous tasks

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

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

340[info] - should have a stack safe cancelable

341[info] - sum random synchronous tasks

342[info] - sum random asynchronous tasks

343[info] - both task can fail with error

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

345[info] monix.bio.TaskExecutionModelSuite

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

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

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

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

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

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

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

353[info] monix.bio.TaskEvalAsyncSuite

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

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

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

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

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

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

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

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

362[info] - IO.evalAsync.coeval

363[info] monix.bio.TaskRejectedExecutionSuite

365[info] monix.bio.IOStartAndForgetSuite

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

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

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

369[info] - IO#startAndForget is stack safe

370[info] monix.bio.TaskEffectInstanceSuite

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

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

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

374[info] monix.bio.TaskMemoizeSuite

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

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

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

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

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

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

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

382[info] - IO.memoize.materialize

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

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

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

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

387[info] - IO.eval.memoize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

402[info] - IO.memoize effects, sequential

403[info] - IO.memoize effects, parallel

404[info] - IO.suspend.memoize effects

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

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

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

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

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

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

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

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

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

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

415[info] - TaskRunLoop.startLightWithBiCallback for success

416[info] - TaskRunLoop.startLightWithBiCallback for failure

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

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

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

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

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

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

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

424[info] monix.bio.TaskCallbackSafetySuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

442[info] monix.bio.TaskParSequenceSuite

443[info] - IO.parSequence should execute in parallel for async tasks

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

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

446[info] - IO.parSequence should be canceled

447[info] - IO.parSequence should be stack safe for synchronous tasks

448[info] - IO.parSequence runAsync multiple times

449[info] - IO.parSequence should log errors if multiple errors happen

450[info] - IO.parSequence should log terminal errors if multiple errors happen

451[info] monix.bio.TaskVoidSuite

452[info] - IO.void should work

453[info] monix.bio.TaskExecuteAsyncSuite

454[info] - IO.now.executeAsync should execute async

455[info] - IO.now.executeOn should execute async if forceAsync = true

456[info] - IO.now.executeOn should not execute async if forceAsync = false

457[info] - IO.create.executeOn should execute async

458[info] - executeAsync should be stack safe, test 1

459[info] - IO.executeOn should be stack safe, test 2

460[info] - executeAsync should be stack safe, test 3

461[info] monix.bio.TaskOptionsSuite

462[info] - change options with future

463[info] - change options with callback

464[info] monix.bio.TaskParTraverseNSuite

465[info] - IO.parTraverseN allows fully sequential execution

466[info] - IO.parTraverseN allows fully concurrent execution

467[info] - IO.parTraverseN allows partially concurrent execution

468[info] - IO.parTraverseN returns an error when fully sequential execution fails in a typed way

469[info] - IO.parTraverseN returns an error when fully sequential execution fails in a terminal way

470[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a typed way

471[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a terminal way

472[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a typed way

473[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a terminal way

475[info] - IO.parTraverseN should be cancelable

476[info] - IO.parTraverseN should be stack safe for synchronous tasks with low parallelism

477[info] - IO.parTraverseN should be stack safe for asynchronous tasks with low parallelism

478[info] - IO.parTraverseN should be stack safe for synchronous tasks with high parallelism

479[info] - IO.parTraverseN should be stack safe for asynchronous tasks with high parallelism

480[info] - IO.parTraverseN allows running the same effect multiple times

481[info] - IO.parTraverseN allows reusing a memoized effect multiple times

482[info] monix.bio.TaskAsyncBoundarySuite

483[info] - IO.asyncBoundary should work

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

485[info] - IO.asyncBoundary should preserve locals

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

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

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

489[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

718[info] monix.bio.TaskConversionsKSuite

719[info] - Task.liftTo[CIO]

720[info] - Task.liftToAsync[IO]

721[info] - Task.liftToConcurrent[IO]

722[info] - Task.liftFrom[IO]

723[info] - Task.liftFromEffect[IO]

724[info] - Task.liftFromConcurrentEffect[IO]

725[info] monix.bio.TaskAsyncSuite

726[info] - IO.never should never complete

727[info] - IO.async should execute

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

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

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

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

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

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

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

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

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

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

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

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

740[info] monix.bio.TaskParSequenceNSuite

741[info] - IO.parSequenceN should execute in parallel bounded by parallelism

742[info] - IO.parSequenceN should return result in order

743[info] - IO.parSequenceN should return empty list

744[info] - IO.parSequenceN should handle single item

745[info] - IO.parSequenceN should handle parallelism bigger than list

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

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

748[info] - IO.parSequenceN should be canceled

749[info] - IO.parSequenceN should be stack safe for synchronous tasks

750[info] - IO.parSequenceN runAsync multiple times

751[info] - IO.parSequenceN should log errors if multiple errors happen

752[info] - IO.parSequenceN should log terminal errors if multiple errors happen

753Hello World!

754[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

982[info] - Applicative[Task.Par].applicative.ap consistent with product + map

983[info] - Applicative[Task.Par].applicative.applicative homomorphism

984[info] - Applicative[Task.Par].applicative.applicative identity

985[info] - Applicative[Task.Par].applicative.applicative interchange

986[info] - Applicative[Task.Par].applicative.applicative map

987[info] - Applicative[Task.Par].applicative.applicative unit

988[info] - Applicative[Task.Par].applicative.apply composition

989[info] - Applicative[Task.Par].applicative.covariant composition

990[info] - Applicative[Task.Par].applicative.covariant identity

991[info] - Applicative[Task.Par].applicative.invariant composition

992[info] - Applicative[Task.Par].applicative.invariant identity

993[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

994[info] - Applicative[Task.Par].applicative.map2/product-map consistency

995[info] - Applicative[Task.Par].applicative.monoidal left identity

996[info] - Applicative[Task.Par].applicative.monoidal right identity

997[info] - Applicative[Task.Par].applicative.productL consistent map2

998[info] - Applicative[Task.Par].applicative.productR consistent map2

999[info] - Applicative[Task.Par].applicative.semigroupal associativity

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1026Cancelling!

1027Received: $value

1028Hello!

1029Hello!

1030Success: 42

1031[info] monix.bio.IODoctest

1032[info] - IO.scala:52: IO

1033[info] - IO.scala:474: runToFuture

1034[info] - IO.scala:541: runToFutureOpt

1035[info] - IO.scala:586: runAsync

1036[info] - IO.scala:661: runAsyncOpt

1037[info] - IO.scala:716: runAsyncF

1038[info] - IO.scala:821: runAsyncAndForget

1039[info] - IO.scala:874: runAsyncUncancelable

1040[info] - IO.scala:947: runSyncStep

1041[info] - IO.scala:1011: runSyncUnsafe

1042[info] - IO.scala:1116: memoize

1043[info] - IO.scala:1155: memoizeOnSuccess

1044[info] - IO.scala:1213: >>

1045[info] - IO.scala:1226: *>

1046[info] - IO.scala:1242: <*

1047[info] - IO.scala:1257: asyncBoundary

1048[info] - IO.scala:1306: asyncBoundary

1049[info] - IO.scala:1337: bracket

1050[info] - IO.scala:1525: delayExecution

1051[info] - IO.scala:1554: delayResult

1052[info] - IO.scala:1595: executeOn

1053[info] - IO.scala:1730: executeAsync

1054[info] - IO.scala:1756: executeWithModel

1055[info] - IO.scala:1774: executeWithOptions

1056[info] - IO.scala:1801: flip

1057[info] - IO.scala:1831: flipWith

1058[info] - IO.scala:1879: flatMapLoop

1059[info] - IO.scala:1937: loopForever

1060[info] - IO.scala:2008: onCancelRaiseError

1061[info] - IO.scala:2062: mapErrorPartialWith

1062[info] - IO.scala:2113: tapError

1063[info] - IO.scala:2147: onErrorRestartIf

1064[info] - IO.scala:2167: onErrorRestartLoop

1065[info] - IO.scala:2242: mapError

1066[info] - IO.scala:2261: mapErrorPartial

1067[info] - IO.scala:2296: start

1068[info] - IO.scala:2324: to

1069[info] - IO.scala:2366: toConcurrent

1070[info] - IO.scala:2412: toAsync

1071[info] - IO.scala:2536: uncancelable

1072[info] - IO.scala:2559: timed

1073[info] - IO.scala:2608: timeoutToL

1074[info] - IO.scala:2663: hideErrors

1075[info] - IO.scala:2684: hideErrorsWith

1076[info] - IO.scala:2740: absorb

1077[info] - IO.scala:2758: absorbWith

1078[info] - IO.scala:2782: IO

1079[info] - IO.scala:2843: apply

1080[info] - IO.scala:2905: deferAction

1081[info] - IO.scala:2932: deferFuture

1082[info] - IO.scala:2945: deferFutureAction

1083[info] - IO.scala:3082: fromConcurrentEffect

1084[info] - IO.scala:3119: fromEffect

1085[info] - IO.scala:3149: fromOption

1086[info] - IO.scala:3165: fromOption

1087[info] - IO.scala:3185: fromOptionEval

1088[info] - IO.scala:3243: async

1089[info] - IO.scala:3303: async0

1090[info] - IO.scala:3399: cancelable

1091[info] - IO.scala:3479: cancelable0

1092[info] - IO.scala:3581: cancelBoundary

1093[info] - IO.scala:3617: create

1094[info] - IO.scala:3724: race

1095[info] - IO.scala:3757: raceMany

1096[info] - IO.scala:3778: racePair

1097[info] - IO.scala:3861: sleep

1098[info] - IO.scala:3952: parSequence

1099[info] - IO.scala:4011: parSequenceN

1100[info] - IO.scala:4042: parTraverseN

1101[info] - IO.scala:4079: parSequenceUnordered

1102[info] - IO.scala:4127: mapBoth

1103[info] - IO.scala:4146: map2

1104[info] - IO.scala:4175: map3

1105[info] - IO.scala:4205: map4

1106[info] - IO.scala:4238: map5

1107[info] - IO.scala:4276: map6

1108[info] - IO.scala:4316: parMap2

1109[info] - IO.scala:4351: parMap3

1110[info] - IO.scala:4389: parMap4

1111[info] - IO.scala:4430: parMap5

1112[info] - IO.scala:4476: parMap6

1113[info] - IO.scala:4562: liftTo

1114[info] - IO.scala:4622: liftFrom

1115[info] - IO.scala:5282: catsParallel

1116[info] monix.bio.IODoOnFinishSuite

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

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

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

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

1121[info] monix.bio.TaskCancellationSuite

1122[info] - cancellation works for async actions

1123[info] - cancellation works for autoCancelableRunLoops

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

1125[info] - uncancelable works for async actions

1126[info] - uncancelable works for autoCancelableRunLoops

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

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

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

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

1131[info] - cancelBoundary happy path

1132[info] - cancelBoundary execution is immediate

1133[info] - cancelBoundary is stack safe

1134[info] - cancelBoundary cancels

1135[info] - onCancelRaiseError resets cancellation flag

1136[info] - errors raised after cancel get reported

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

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

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

1140[info] - local.write.uncancelable works

1141[info] - local.write.onCancelRaiseError works

1142[info] monix.bio.tracing.StackTracedContextSuite

1143[info] - push traces

1144[info] - track omitted frames

1145[info] monix.bio.IOLocalJVMSuite

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

1147[info] - locals get transported with executeWithModel

1148[info] - locals get transported with executeWithOptions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1167[info] monix.bio.TaskLikeConversionsJava8Suite

1168[info] - IO.from converts successful CompletableFuture

1169[info] - IO.from converts failed CompletableFuture

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

1171[info] monix.bio.TaskCallbackSuite

1172[info] - onValue should invoke onSuccess

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

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

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

1176[info] - contramap should pipe onError

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

1178[info] - BiCallback.fromPromise (success)

1179[info] - BiCallback.fromPromise (failure)

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

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

1182[info] - BiCallback.empty reports errors

1183[info] - BiCallback.empty reports terminal errors

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

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

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

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

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

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

1190[info] - fromAttempt success

1191[info] - fromAttempt error

1192[info] - fromAttempt termination

1193[info] monix.bio.TaskParSequenceUnorderedSuite

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

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

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

1197[info] - IO.parSequenceUnordered should be canceled

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

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

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

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

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

1203[info] - IO.parSequenceUnordered runAsync multiple times

1204[info] monix.bio.TaskToStringSuite

1205[info] - IO.Now

1206[info] - IO.Error

1207[info] - IO.Termination

1208[info] - IO.Eval

1209[info] - IO.EvalTotal

1210[info] - IO.Async

1211[info] - IO.FlatMap

1212[info] - IO.Suspend

1213[info] - IO.SuspendTotal

1214[info] - IO.Map

1215[info] monix.bio.TaskFromFutureSuite

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

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

1218[info] - Task.fromFuture should work onSuccess

1219[info] - Task.fromFuture should work onError

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

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

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

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

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

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

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

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

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

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

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

1231[info] monix.bio.IOFromFutureEitherSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

1245[info] monix.bio.TaskTerminationSuite

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

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

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

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

1250[info] - IO#redeemCauseWith derives flatMap

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

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

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

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

1255[info] monix.bio.TaskConnectionRefSuite

1256[info] - assign and cancel a Cancelable

1257[info] - assign and cancel a CancelableF

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

1259[info] - cancel a Cancelable on single assignment

1260[info] - cancel a CancelableF on single assignment

1261[info] - cancel a Task on single assignment

1262[info] monix.bio.IOLikeDoctest

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

1264[info] monix.bio.TaskTraverseSuite

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

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

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

1268[info] - IO.traverse should be canceled

1269[info] monix.bio.TaskMaterializeSuite

1270[info] - IO.now.materialize

1271[info] - IO.error.materialize

1272[info] - IO.terminate.materialize

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

1274[info] - IO.eval.materialize

1275[info] - IO.defer.materialize

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

1277[info] - IO.flatMap.materialize

1278[info] - IO.evalAsync.materialize

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

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

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

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

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

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

1285[info] - IO.now.dematerialize

1286[info] - IO.error.dematerialize

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

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

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

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

1291[info] - IO.materialize on failing flatMap

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

1293[info] - IO.raiseError.dematerialize

1294[info] - IO.terminate.dematerialize

1295[info] monix.bio.TaskParTraverseSuite

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

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

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

1299[info] - IO.parTraverse should be canceled

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

1301[info] - IO.parTraverse runAsync multiple times

1303[info] monix.bio.TaskExecuteWithOptionsSuite

1304[info] - executeWithOptions works

1305[info] - local.write.executeWithOptions

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

1307[info] monix.bio.TaskNowSuite

1308[info] - IO.now should work synchronously

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

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

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

1312[info] - IO.raiseError should work synchronously

1313[info] - IO.terminate should work synchronously

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

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

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

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

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

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

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

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

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

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

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

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

1326[info] - IO.now.runSyncStep

1327[info] - IO.raiseError.runSyncStep

1328[info] monix.bio.TaskExecuteWithModelSuite

1329[info] - executeWithModel works

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

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

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

1333[info] monix.bio.TaskFlipSuite

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

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

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

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

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

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

1340Executing...

1341Executing...

1342Received: $str

1343Executing...

1344Finished via exit code: $exitCode

1345Resources were released!

1346Executing...

1347Received: $str

1348[info] monix.bio.TaskDelaySuite

1349[info] - IO#delayExecution should work

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

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

1352[info] - IO#delayExecution is cancelable

1353[info] - IO#delayResult should work

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

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

1356[info] - IO#delayResult is cancelable

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

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

1359[info] monix.bio.TaskCallbackSafetyJVMSuite

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

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

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

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

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

1365[info] monix.bio.FiberDoctest

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

1367[info] monix.bio.IOLocalSuite

1368[info] - IOLocal.apply

1369[info] - IOLocal.wrap

1370[info] - IOLocal!.bind

1371[info] - IOLocal!.bindL

1372[info] - IOLocal!.bindClear

1373[info] - IOLocal canceled

1374[info] - IOLocal!.local

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

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

1377[info] - IOLocal should work with bracket

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

1379[info] - IOLocal interop with future via deferFutureAction

1380[info] - IOLocal.bind scoping works

1381[info] - IOLocal.bind actually isolates reads

1382[info] - IOLocal.isolate with ConcurrentChannel

1383[info] monix.bio.TaskExecuteOnSuite

1384[info] - executeOn(forceAsync = false)

1385[info] - executeOn(forceAsync = true)

1386[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1

1387[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2

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

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

1390[info] monix.bio.TaskParTraverseUnorderedSuite

1391[info] - IO.parTraverseUnordered should execute in parallel

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

1393[info] - IO.parTraverseUnordered should be canceled

1394[info] - IO.parTraverseUnordered should run over an iterable

1395[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks

1396[info] - IO.parTraverseUnordered should be stack safe on success

1397[info] - IO.parTraverseUnordered should log errors if multiple errors happen

1398[info] - IO.parTraverseUnordered runAsync multiple times

1400[info] monix.bio.TaskAsyncAutoShiftJVMSuite

1401[info] - Task.fromFuture(async) should shift back to the main scheduler

1402[info] - Task.fromFuture(completed) should not shift to the main scheduler

1403[info] - Task.fromFuture(async error) should shift back to the main scheduler

1404[info] - Task.fromFuture(completed error) should not shift to the main scheduler

1405[info] - Task.deferFuture(async) should shift back to the main scheduler

1406[info] - Task.deferFuture(completed) should not shift to the main scheduler

1407[info] - Task.deferFuture(async error) should shift back to the main scheduler

1408[info] - Task.deferFuture(completed error) should not shift to the main scheduler

1409[info] - Task.deferFutureAction(async) should shift back to the main scheduler

1410[info] - Task.deferFutureAction(completed) should not shift to the main scheduler

1411[info] - Task.deferFutureAction(async error) should shift back to the main scheduler

1412[info] - Task.deferFutureAction(completed error) should not shift to the main scheduler

1413[info] - Task.fromFuture(async cancelable) should shift back to the main scheduler

1414[info] - Task.fromFuture(completed cancelable) should not shift to the main scheduler

1415[info] - Task.fromFuture(async error cancelable) should shift back to the main scheduler

1416[info] - Task.fromFuture(completed error cancelable) should not shift to the main scheduler

1417[info] - Task.deferFuture(async cancelable) should shift back to the main scheduler

1418[info] - Task.deferFuture(completed cancelable) should not shift to the main scheduler

1419[info] - Task.deferFuture(async error cancelable) should shift back to the main scheduler

1420[info] - Task.deferFuture(completed error cancelable) should not shift to the main scheduler

1421[info] - Task.deferFutureAction(async cancelable) should shift back to the main scheduler

1422[info] - Task.deferFutureAction(completed cancelable) should not shift to the main scheduler

1423[info] - Task.deferFutureAction(async error cancelable) should shift back to the main scheduler

1424[info] - Task.deferFutureAction(completed error cancelable) should not shift to the main scheduler

1425[info] - Task.async(register) should shift back if register forks

1426[info] - Task.async(register) should not shift back if register does not fork

1427[info] - Task.async(register typed) should shift back if register forks

1428[info] - Task.async(register error) should not shift back if register does not fork

1429[info] - Task.async0(register) should shift back if register forks

1430[info] - Task.async0(register) should not shift back if register does not fork

1431[info] - Task.async0(register error) should shift back if register forks

1432[info] - Task.async0(register error) should not shift back if register does not fork

1433[info] - Task.cancelable(register) should shift back if register forks

1434[info] - Task.cancelable(register) should not shift back if register does not fork

1435[info] - Task.cancelable(register error) should shift back if register forks

1436[info] - Task.cancelable(register error) should not shift back if register does not fork

1437[info] - Task.cancelable0(register) should shift back if register forks

1438[info] - Task.cancelable0(register) should not shift back if register does not fork

1439[info] - Task.cancelable0(register error) should shift back if register forks

1440[info] - Task.cancelable0(register error) should not shift back if register does not fork

1441[info] - Task.create(register) should shift back if register forks

1442[info] - Task.create(register) should not shift back if register does not fork

1443[info] - Task.create(register error) should shift back if register forks

1444[info] - Task.create(register error) should not shift back if register does not fork

1445[info] - Task.asyncF(register) should shift back if register forks

1446[info] - Task.asyncF(register) should not shift back if register does not fork

1447[info] - Task.asyncF(register error) should shift back if register forks

1448[info] - Task.asyncF(register error) should not shift back if register does not fork

1449[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite

1450[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1451[info] - CoflatMap[Task].coflatMap.coflatMap identity

1452[info] - CoflatMap[Task].coflatMap.coflatten coherence

1453[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1454[info] - CoflatMap[Task].coflatMap.covariant composition

1455[info] - CoflatMap[Task].coflatMap.covariant identity

1456[info] - CoflatMap[Task].coflatMap.invariant composition

1457[info] - CoflatMap[Task].coflatMap.invariant identity

1458[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

1459[info] - Concurrent[Task].async.ap consistent with product + map

1460[info] - Concurrent[Task].async.applicative homomorphism

1461[info] - Concurrent[Task].async.applicative identity

1462[info] - Concurrent[Task].async.applicative interchange

1463[info] - Concurrent[Task].async.applicative map

1464[info] - Concurrent[Task].async.applicative unit

1465[info] - Concurrent[Task].async.applicativeError adaptError pure

1466[info] - Concurrent[Task].async.applicativeError adaptError raise

1467[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

1468[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

1469[info] - Concurrent[Task].async.applicativeError handle

1470[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

1471[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

1472[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

1473[info] - Concurrent[Task].async.applicativeError handleError pure

1474[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

1475[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

1476[info] - Concurrent[Task].async.applicativeError handleWith

1477[info] - Concurrent[Task].async.applicativeError onError pure

1478[info] - Concurrent[Task].async.applicativeError onError raise

1479[info] - Concurrent[Task].async.applicativeError pure attempt

1480[info] - Concurrent[Task].async.applicativeError raiseError attempt

1481[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

1482[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

1483[info] - Concurrent[Task].async.apply composition

1484[info] - Concurrent[Task].async.async can be derived from asyncF

1485[info] - Concurrent[Task].async.async left is raiseError

1486[info] - Concurrent[Task].async.async right is pure

1487[info] - Concurrent[Task].async.bind suspends evaluation

1488[info] - Concurrent[Task].async.bracket is derived from bracketCase

1489[info] - Concurrent[Task].async.bracket release is called on Completed or Error

1490[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

1491[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

1492[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1493[info] - Concurrent[Task].async.covariant composition

1494[info] - Concurrent[Task].async.covariant identity

1495[info] - Concurrent[Task].async.delay constant is pure

1496[info] - Concurrent[Task].async.flatMap associativity

1497[info] - Concurrent[Task].async.flatMap consistent apply

1498[info] - Concurrent[Task].async.flatMap from tailRecM consistency

1499[info] - Concurrent[Task].async.guarantee is derived from bracket

1500[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

1501[info] - Concurrent[Task].async.invariant composition

1502[info] - Concurrent[Task].async.invariant identity

1503[info] - Concurrent[Task].async.map flatMap coherence

1504[info] - Concurrent[Task].async.map suspends evaluation

1505[info] - Concurrent[Task].async.map2/map2Eval consistency

1506[info] - Concurrent[Task].async.map2/product-map consistency

1507[info] - Concurrent[Task].async.monad left identity

1508[info] - Concurrent[Task].async.monad right identity

1509[info] - Concurrent[Task].async.monadError ensure consistency

1510[info] - Concurrent[Task].async.monadError ensureOr consistency

1511[info] - Concurrent[Task].async.monadError left zero

1512[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

1513[info] - Concurrent[Task].async.monadError rethrow attempt

1514[info] - Concurrent[Task].async.monoidal left identity

1515[info] - Concurrent[Task].async.monoidal right identity

1516[info] - Concurrent[Task].async.mproduct consistent flatMap

1517[info] - Concurrent[Task].async.never is derived from async

1518[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

1519[info] - Concurrent[Task].async.productL consistent map2

1520[info] - Concurrent[Task].async.productR consistent map2

1521[info] - Concurrent[Task].async.propagate errors through bind (async)

1522[info] - Concurrent[Task].async.propagate errors through bind (suspend)

1523[info] - Concurrent[Task].async.repeated async evaluation not memoized

1524[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

1525[info] - Concurrent[Task].async.repeated sync evaluation not memoized

1526[info] - Concurrent[Task].async.semigroupal associativity

1527[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

1528[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

1529[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

1530[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

1531[info] - Concurrent[Task].async.stack-safe on left-associated binds

1532[info] - Concurrent[Task].async.stack-safe on repeated attempts

1533[info] - Concurrent[Task].async.stack-safe on repeated maps

1534[info] - Concurrent[Task].async.stack-safe on right-associated binds

1535[info] - Concurrent[Task].async.suspend constant is pure join

1536[info] - Concurrent[Task].async.tailRecM consistent flatMap

1537[info] - Concurrent[Task].async.tailRecM stack safety

1538[info] - Concurrent[Task].async.throw in delay is raiseError

1539[info] - Concurrent[Task].async.throw in suspend is raiseError

1540[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

1541[info] - Concurrent[Task].async.unsequenced delay is no-op

1542[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

1543[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

1544[info] - ConcurrentEffect[Task].effect.applicative homomorphism

1545[info] - ConcurrentEffect[Task].effect.applicative identity

1546[info] - ConcurrentEffect[Task].effect.applicative interchange

1547[info] - ConcurrentEffect[Task].effect.applicative map

1548[info] - ConcurrentEffect[Task].effect.applicative unit

1549[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

1550[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

1551[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

1552[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

1553[info] - ConcurrentEffect[Task].effect.applicativeError handle

1554[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

1555[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

1556[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

1557[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

1558[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

1559[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

1560[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

1561[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

1562[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

1563[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

1564[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

1565[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

1566[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

1567[info] - ConcurrentEffect[Task].effect.apply composition

1568[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

1569[info] - ConcurrentEffect[Task].effect.async left is raiseError

1570[info] - ConcurrentEffect[Task].effect.async right is pure

1571[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

1572[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

1573[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

1574[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

1575[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

1576[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1577[info] - ConcurrentEffect[Task].effect.covariant composition

1578[info] - ConcurrentEffect[Task].effect.covariant identity

1579[info] - ConcurrentEffect[Task].effect.delay constant is pure

1580[info] - ConcurrentEffect[Task].effect.flatMap associativity

1581[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

1582[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

1583[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

1584[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

1585[info] - ConcurrentEffect[Task].effect.invariant composition

1586[info] - ConcurrentEffect[Task].effect.invariant identity

1587[info] - ConcurrentEffect[Task].effect.map flatMap coherence

1588[info] - ConcurrentEffect[Task].effect.map suspends evaluation

1589[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

1590[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

1591[info] - ConcurrentEffect[Task].effect.monad left identity

1592[info] - ConcurrentEffect[Task].effect.monad right identity

1593[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

1594[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

1595[info] - ConcurrentEffect[Task].effect.monadError left zero

1596[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

1597[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

1598[info] - ConcurrentEffect[Task].effect.monoidal left identity

1599[info] - ConcurrentEffect[Task].effect.monoidal right identity

1600[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

1601[info] - ConcurrentEffect[Task].effect.never is derived from async

1602[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

1603[info] - ConcurrentEffect[Task].effect.productL consistent map2

1604[info] - ConcurrentEffect[Task].effect.productR consistent map2

1605[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

1606[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

1607[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

1608[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

1609[info] - ConcurrentEffect[Task].effect.repeated callback ignored

1610[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

1611[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

1612[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

1613[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

1614[info] - ConcurrentEffect[Task].effect.semigroupal associativity

1615[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

1616[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

1617[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

1618[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

1619[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

1620[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

1621[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

1622[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

1623[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

1624[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

1625[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

1626[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

1627[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

1628[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

1629[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

1630[info] - ConcurrentEffect[Task].effect.toIO stack safety

1631[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

1632[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

1633[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

1634[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

1635[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

1636[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

1637[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

1638[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

1639[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

1640[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

1641[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

1642[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

1643[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

1644[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

1645[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

1646[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

1647[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

1648[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

1649[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

1650[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

1651[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

1652[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1653[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1654[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1655[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1656[info] - Monoid[IO[Throwable, Int]].monoid.associative

1657[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1658[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1659[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1660[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1661[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1662[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1663[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1664[info] - Monoid[IO[Throwable, Int]].monoid.is id

1665[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1666[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1667[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1668[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1669[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1670[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1671[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1672[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1673[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1674[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1675[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1676[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1677[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1678[info] monix.bio.TaskTimedSuite

1679[info] - measure tasks with no errors

1680[info] - not measure tasks with typed errors

1681[info] - not measure tasks with terminal errors

1682[info] - measure tasks with typed errors followed by `.attempt`

1683[info] - not measure tasks with terminal errors followed by `.attempt`

1684[info] - stack safety

1685[info] monix.bio.TaskGuaranteeSuite

1686[info] - finalizer is evaluated on success

1687[info] - finalizer is evaluated on error

1688[info] - finalizer is evaluated on terminal error

1689[info] - if finalizer throws, report finalizer error and signal use error

1690[info] - finalizer is evaluated on cancelation (1)

1691[info] - finalizer is evaluated on cancellation (2)

1692[info] - stack-safety (1)

1693[info] - stack-safety (2)

1694[info] - stack-safety (3)

1695[info] monix.bio.TaskConnectionSuite

1696[info] - initial push

1697[info] - cancels Task after being canceled

1698[info] - cancels Cancelable after being canceled

1699[info] - cancels CancelableF after being canceled

1700[info] - push two, pop one

1701[info] - cancel the second time is a no-op

1702[info] - push two, pop two

1703[info] - push(Cancelable)

1704[info] - push(Cancelable) then pop

1705[info] - push(CancelToken)

1706[info] - push(CancelToken) then pop

1707[info] - pop when self is empty

1708[info] - pop when self is canceled

1709[info] - cancel mixture

1710[info] - cancel mixture after being cancelled

1711[info] - tryReactive

1712[info] - toCancelable

1713[info] - uncancelable ref is shared

1714[info] - uncancelable ops

1715[info] - throwing error in Task on cancel all

1716[info] - throwing multiple errors in Tasks on cancel all

1717[info] - throwing error in Task after cancel

1718[info] - throwing error in Cancelable on cancel all

1719[info] - throwing multiple errors in Cancelables on cancel all

1720[info] - throwing error in Cancelable after cancel

1721[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite

1722[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1723[info] - CoflatMap[Task].coflatMap.coflatMap identity

1724[info] - CoflatMap[Task].coflatMap.coflatten coherence

1725[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1726[info] - CoflatMap[Task].coflatMap.covariant composition

1727[info] - CoflatMap[Task].coflatMap.covariant identity

1728[info] - CoflatMap[Task].coflatMap.invariant composition

1729[info] - CoflatMap[Task].coflatMap.invariant identity

1730[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1731[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1732[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1733[info] - Concurrent[Task].concurrent.ap consistent with product + map

1734[info] - Concurrent[Task].concurrent.applicative homomorphism

1735[info] - Concurrent[Task].concurrent.applicative identity

1736[info] - Concurrent[Task].concurrent.applicative interchange

1737[info] - Concurrent[Task].concurrent.applicative map

1738[info] - Concurrent[Task].concurrent.applicative unit

1739[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1740[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1741[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1742[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1743[info] - Concurrent[Task].concurrent.applicativeError handle

1744[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1745[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1746[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1747[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1748[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

1749[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

1750[info] - Concurrent[Task].concurrent.applicativeError handleWith

1751[info] - Concurrent[Task].concurrent.applicativeError onError pure

1752[info] - Concurrent[Task].concurrent.applicativeError onError raise

1753[info] - Concurrent[Task].concurrent.applicativeError pure attempt

1754[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

1755[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

1756[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

1757[info] - Concurrent[Task].concurrent.apply composition

1758[info] - Concurrent[Task].concurrent.async can be derived from asyncF

1759[info] - Concurrent[Task].concurrent.async cancelable coherence

1760[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

1761[info] - Concurrent[Task].concurrent.async left is raiseError

1762[info] - Concurrent[Task].concurrent.async right is pure

1763[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

1764[info] - Concurrent[Task].concurrent.bind suspends evaluation

1765[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

1766[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

1767[info] - Concurrent[Task].concurrent.bracket release is called on cancel

1768[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

1769[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

1770[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1771[info] - Concurrent[Task].concurrent.covariant composition

1772[info] - Concurrent[Task].concurrent.covariant identity

1773[info] - Concurrent[Task].concurrent.delay constant is pure

1774[info] - Concurrent[Task].concurrent.flatMap associativity

1775[info] - Concurrent[Task].concurrent.flatMap consistent apply

1776[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

1777[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

1778[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

1779[info] - Concurrent[Task].concurrent.invariant composition

1780[info] - Concurrent[Task].concurrent.invariant identity

1781[info] - Concurrent[Task].concurrent.join is idempotent

1782[info] - Concurrent[Task].concurrent.map flatMap coherence

1783[info] - Concurrent[Task].concurrent.map suspends evaluation

1784[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

1785[info] - Concurrent[Task].concurrent.map2/product-map consistency

1786[info] - Concurrent[Task].concurrent.monad left identity

1787[info] - Concurrent[Task].concurrent.monad right identity

1788[info] - Concurrent[Task].concurrent.monadError ensure consistency

1789[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

1790[info] - Concurrent[Task].concurrent.monadError left zero

1791[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

1792[info] - Concurrent[Task].concurrent.monadError rethrow attempt

1793[info] - Concurrent[Task].concurrent.monoidal left identity

1794[info] - Concurrent[Task].concurrent.monoidal right identity

1795[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

1796[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

1797[info] - Concurrent[Task].concurrent.productL consistent map2

1798[info] - Concurrent[Task].concurrent.productR consistent map2

1799[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

1800[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

1801[info] - Concurrent[Task].concurrent.race cancels both

1802[info] - Concurrent[Task].concurrent.race cancels loser

1803[info] - Concurrent[Task].concurrent.race mirrors left winner

1804[info] - Concurrent[Task].concurrent.race mirrors right winner

1805[info] - Concurrent[Task].concurrent.racePair can join left

1806[info] - Concurrent[Task].concurrent.racePair can join right

1807[info] - Concurrent[Task].concurrent.racePair cancels both

1808[info] - Concurrent[Task].concurrent.racePair cancels loser

1809[info] - Concurrent[Task].concurrent.racePair mirrors left winner

1810[info] - Concurrent[Task].concurrent.racePair mirrors right winner

1811[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

1812[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

1813[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

1814[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

1815[info] - Concurrent[Task].concurrent.semigroupal associativity

1816[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

1817[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

1818[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

1819[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

1820[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

1821[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

1822[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

1823[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

1824[info] - Concurrent[Task].concurrent.start then join is identity

1825[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

1826[info] - Concurrent[Task].concurrent.suspend constant is pure join

1827[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

1828[info] - Concurrent[Task].concurrent.tailRecM stack safety

1829[info] - Concurrent[Task].concurrent.throw in delay is raiseError

1830[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

1831[info] - Concurrent[Task].concurrent.uncancelable mirrors source

1832[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

1833[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

1834[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

1835[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

1836[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

1837[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

1838[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

1839[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

1840[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

1841[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

1842[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

1843[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

1844[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

1845[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

1846[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

1847[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

1848[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

1849[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

1850[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

1851[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

1852[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

1853[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

1854[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

1855[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

1856[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

1857[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

1858[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

1859[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

1860[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

1861[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

1862[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

1863[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

1864[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

1865[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

1866[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

1867[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

1868[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

1869[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

1870[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

1871[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

1872[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

1873[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

1874[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1875[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

1876[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

1877[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

1878[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

1879[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

1880[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

1881[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

1882[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

1883[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

1884[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

1885[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

1886[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

1887[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

1888[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

1889[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

1890[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

1891[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

1892[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

1893[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

1894[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

1895[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

1896[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

1897[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

1898[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

1899[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

1900[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

1901[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

1902[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

1903[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

1904[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

1905[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

1906[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

1907[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

1908[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

1909[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

1910[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

1911[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

1912[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

1913[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

1914[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

1915[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

1916[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

1917[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

1918[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

1919[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

1920[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

1921[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

1922[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

1923[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

1924[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

1925[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

1926[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

1927[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

1928[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

1929[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

1930[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

1931[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

1932[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

1933[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

1934[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

1935[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

1936[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

1937[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

1938[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

1939[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

1940[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

1941[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

1942[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

1943[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

1944[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

1945[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

1946[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

1947[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

1948[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

1949[info] - Applicative[Task.Par].applicative.ap consistent with product + map

1950[info] - Applicative[Task.Par].applicative.applicative homomorphism

1951[info] - Applicative[Task.Par].applicative.applicative identity

1952[info] - Applicative[Task.Par].applicative.applicative interchange

1953[info] - Applicative[Task.Par].applicative.applicative map

1954[info] - Applicative[Task.Par].applicative.applicative unit

1955[info] - Applicative[Task.Par].applicative.apply composition

1956[info] - Applicative[Task.Par].applicative.covariant composition

1957[info] - Applicative[Task.Par].applicative.covariant identity

1958[info] - Applicative[Task.Par].applicative.invariant composition

1959[info] - Applicative[Task.Par].applicative.invariant identity

1960[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

1961[info] - Applicative[Task.Par].applicative.map2/product-map consistency

1962[info] - Applicative[Task.Par].applicative.monoidal left identity

1963[info] - Applicative[Task.Par].applicative.monoidal right identity

1964[info] - Applicative[Task.Par].applicative.productL consistent map2

1965[info] - Applicative[Task.Par].applicative.productR consistent map2

1966[info] - Applicative[Task.Par].applicative.semigroupal associativity

1967[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1968[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1969[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1970[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1971[info] - Monoid[IO[Throwable, Int]].monoid.associative

1972[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1973[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1974[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1975[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1976[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1977[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1978[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1979[info] - Monoid[IO[Throwable, Int]].monoid.is id

1980[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1981[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1982[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1983[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1984[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1985[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1986[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1987[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1988[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1989[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1990[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1991[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1992[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1993[info] monix.bio.TaskMiscSuite

1994[info] - IO.attempt should succeed

1995[info] - IO.raiseError.attempt should expose error

1996[info] - IO.mapError should map error

1997[info] - IO.terminate.attempt should not expose error

1998[info] - IO.tapError should not alter original successful value

1999[info] - IO.tapError should not alter original error value

2000[info] - IO.tapError should not alter original terminal error

2001[info] - IO.failed should expose error

2002[info] - IO.failed should fail for successful values

2003[info] - IO.map protects against user code

2004[info] - IO.forever

2005[info] - IO.restartUntil should keep retrying IO until predicate succeeds

2006[info] - IO.toReactivePublisher should convert tasks with no errors

2007[info] - IO.toReactivePublisher should convert tasks with typed errors

2008[info] - IO.toReactivePublisher should convert tasks with terminal errors

2009[info] - IO.toReactivePublisher should be cancelable

2010[info] - IO.toReactivePublisher should throw errors on invalid requests

2011[info] - IO.pure is an alias of now

2012[info] - IO.now.runAsync with Try-based callback

2013[info] - Task.error.runAsync with Try-based callback

2014[info] - Task.terminate.runAsync with Try-based callback

2015[info] - task.executeAsync.runAsync with Try-based callback for success

2016[info] - task.executeAsync.runAsync with Try-based callback for error

2017[info] - task.executeAsync.runAsync with Try-based callback for terminal error

2018[info] - task.executeWithOptions protects against user error

2019[info] monix.bio.TaskDeferActionSuite

2020[info] - IO.deferAction works

2021[info] - IO.deferAction works for failed tasks

2022[info] - IO.deferAction protects against user error

2023[info] - IO.deferAction should properly cast errors

2024[info] - IO.deferAction is stack safe

2025[info] - IO.deferAction(local.write) works

2026[info] monix.bio.TaskCreateSuite

2027[info] - can use Unit as return type

2028[info] - can use Cancelable.empty as return type

2029[info] - returning Unit yields non-cancelable tasks

2030[info] - can use Cancelable as return type

2031[info] - returning Cancelable yields a cancelable task

2032[info] - can use CIO[Unit] as return type

2033[info] - returning CIO[Unit] yields a cancelable task

2034[info] - can use IO[E, Unit] as return type

2035[info] - returning IO[E, Unit] yields a cancelable task

2036[info] - throwing error when returning Unit

2037[info] - throwing error when returning Cancelable

2038[info] monix.bio.TaskMemoizeOnSuccessSuite

2039[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber

2040[info] - IO.memoizeOnSuccess should work synchronously for next subscribers

2041[info] - IO.memoizeOnSuccess should be stack safe

2042[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1

2043[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2

2044[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent

2045[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent

2046[info] - IO.memoizeOnSuccess.materialize

2047[info] - IO.raiseError(error).memoizeOnSuccess.materialize

2048[info] - IO.terminate(error).memoizeOnSuccess.materialize

2049[info] - IO.eval.memoizeOnSuccess should work for first subscriber

2050[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers

2051[info] - IO.eval(error).memoizeOnSuccess should not be idempotent

2052[info] - IO.eval.memoizeOnSuccess

2053[info] - IO.eval.memoizeOnSuccess should be stack safe

2054[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe

2055[info] - IO.defer(evalAlways).memoizeOnSuccess

2056[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber

2057[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers

2058[info] - IO.evalOnce(error).memoizeOnSuccess should work

2059[info] - IO.evalOnce.memoizeOnSuccess should be stack safe

2060[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe

2061[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber

2062[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers

2063[info] - IO.raiseError.memoizeOnSuccess should work

2064[info] - IO.terminate.memoizeOnSuccess should work

2065[info] - IO.now.memoizeOnSuccess should be stack safe

2066[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe

2067[info] - IO.suspend.memoizeOnSuccess should be stack safe

2068[info] - IO.memoizeOnSuccess effects, sequential

2069[info] - IO.memoizeOnSuccess effects, parallel

2070[info] - IO.suspend.memoizeOnSuccess effects

2071[info] - IO.suspend.flatMap.memoizeOnSuccess effects

2072[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future

2073[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback

2074[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback

2075[info] - IO.memoizeOnSuccess should be cancellable (future)

2076[info] - IO.memoizeOnSuccess should be cancellable (callback #1)

2077[info] - IO.memoizeOnSuccess should be cancellable (callback #2)

2078[info] - IO.memoizeOnSuccess should not be cancelable

2079[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners

2080[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess

2081[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess

2082[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess

2083[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess

2084[info] - IO.now.memoizeOnSuccess eq IO.now

2085[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError

2086[info] - IO.terminate.memoizeOnSuccess eq IO.terminate

2087[info] monix.bio.TaskErrorSuite

2088[info] - IO.attempt should expose typed error

2089[info] - IO.attempt should not expose unexpected error

2090[info] - IO.attempt should work for successful values

2091[info] - IO.rethrow should turn Left to typed error

2092[info] - IO.rethrow should turn Right to success value

2093[info] - IO.failed should expose typed error

2094[info] - IO.failed should fail for unexpected error

2095[info] - IO.failed should fail for successful values

2096[info] - IO#onErrorRecover should mirror source on success

2097[info] - IO#onErrorRecover should recover typed error

2098[info] - IO#onErrorRecover should not recover unexpected error

2099[info] - IO#onErrorRecover should protect against user code

2100[info] - IO#onErrorHandle should mirror source on success

2101[info] - IO#onErrorHandle should recover typed error

2102[info] - IO#onErrorHandle should not recover unexpected error

2103[info] - IO#onErrorHandle should protect against user code

2104[info] - IO.onErrorFallbackTo should mirror source onSuccess

2105[info] - IO.onErrorFallbackTo should fallback to backup onError

2106[info] - IO.onErrorFallbackTo should not fallback to backup onTermination

2107[info] - IO.onErrorFallbackTo should protect against user code

2108[info] - IO.onErrorFallbackTo should be cancelable if the ExecutionModel allows it

2109[info] - IO.onErrorRestart should mirror the source onSuccess

2110[info] - IO.onErrorRestart should retry onError

2111[info] - IO.onErrorRestart should emit onError after max retries

2112[info] - IO.onErrorRestart should be cancelable if ExecutionModel permits

2113[info] - IO.onErrorRestart should not restart on terminate error

2114[info] - IO.onErrorRestartIf should mirror the source onSuccess

2115[info] - IO.onErrorRestartIf should retry onError

2116[info] - IO.onErrorRestartIf should emit onError

2117[info] - IO.onErrorRestartIf should be cancelable if ExecutionModel permits

2118[info] - IO.onErrorRestartIf should not restart on terminate error

2119[info] - IO.onErrorRestartIf should restart on typed error

2120[info] - IO#onErrorRecoverWith should mirror source on success

2121[info] - IO#onErrorRecoverWith should recover

2126[info] - IO#onErrorRecoverWith should protect against user code

2127[info] - IO#onErrorRecoverWith has a cancelable fallback

2128[info] - IO#onErrorRecover should emit error if not matches

2129[info] - IO#onErrorRecoverWith should emit error if not matches

2130[info] - IO.eval.flatMap.redeemCauseWith should work

2131[info] - IO.evalAsync.flatMap.redeemCauseWith should work

2132[info] - IO.now.onErrorRecoverWith should be stack safe

2133[info] - onErrorRecoverWith should be stack safe for loop with executeAsync boundaries

2134[info] - Task.onErrorRestartLoop works for success

2135[info] - Task.onErrorRestartLoop can throw different error

2136[info] - Task.onErrorRestartLoop can rethrow

2137[info] monix.bio.TaskClockTimerAndContextShiftSuite

2138[info] - IO.clock is implicit

2139[info] - IO.clock.monotonic

2140[info] - IO.clock.realTime

2141[info] - IO.clock(s2).monotonic

2142[info] - IO.clock(s).realTime

2143[info] - IO.timer is implicit

2144[info] - IO.timer

2145[info] - IO.timer(s)

2146[info] - IO.timer(s).clock

2147[info] - IO.contextShift is implicit

2148[info] - IO.contextShift.shift

2149[info] - IO.contextShift.evalOn(s2)

2150[info] - IO.contextShift.evalOn(s2) failure

2151[info] - IO.contextShift.evalOn(s2) fatal failure

2152[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries

2153[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction

2154[info] - IO.contextShift(s).shift

2155[info] - IO.contextShift(s).evalOn(s2)

2156[info] - IO.contextShift(s).evalOn(s2) failure

2157[info] - IO.contextShift(s).evalOn(s2) fatal failure

2158[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries

2159[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction

2160[info] monix.bio.TaskToFutureSuite

2161[info] - Task.fromFuture for already completed references

2162[info] - Task.deferFuture for already completed references

2163[info] - Task.deferFutureAction for already completed references

2164[info] - Task.fromFuture(error) for already completed references

2165[info] - Task.deferFuture(error) for already completed references

2166[info] - Task.deferFutureAction(typed) for already completed references

2167[info] - Task.fromFuture for completed reference is stack safe (flatMap)

2168[info] - Task.deferFuture for completed reference is stack safe (flatMap)

2169[info] - Task.deferFutureAction for completed reference is stack safe (flatMap)

2170[info] - Task.fromFuture async result

2171[info] - Task.fromFuture(error) async result

2172[info] - Task.deferFuture async result

2173[info] - Task.deferFuture(error) async result

2174[info] - Task.deferFuture(throw error) async result

2175[info] - Task.deferFutureAction async result

2176[info] - Task.deferFutureAction(error) async result

2177[info] - Task.deferFutureAction(throw error) async result

2178[info] - Task.fromFuture(cancelable)

2179[info] - Task.fromFuture(cancelable) is cancelable

2180[info] - Task.deferFuture(cancelable)

2181[info] - Task.deferFuture(cancelable) is cancelable

2182[info] - Task.deferFutureAction(cancelable)

2183[info] - Task.deferFutureAction(cancelable) is cancelable

2184[info] monix.bio.TaskDoOnCancelSuite

2185[info] - doOnCancel should normally mirror the source

2186[info] - doOnCancel should mirror failed sources

2187[info] - doOnCancel should mirror terminated sources

2188[info] - doOnCancel should cancel delayResult #1

2189[info] - doOnCancel should cancel delayResult #2

2190[info] - doOnCancel should cancel delayResult #3

2191[info] - doOnCancel should cancel delayExecution #1

2192[info] - doOnCancel should cancel delayExecution #2

2193[info] - doOnCancel is stack safe in flatMap loops

2194[info] - local.write.doOnCancel works

2195Hello!

2196[info] monix.bio.TaskBracketSuite

2197[info] - equivalence with onErrorHandleWith

2198[info] - equivalence with flatMap + redeemWith

2199[info] - equivalence with flatMap + redeemCauseWith

2200[info] - use is protected against user error

2201[info] - release is evaluated on success

2202[info] - release is evaluated on error

2203[info] - release is evaluated on terminal error

2204[info] - release is evaluated on cancel

2205[info] - if both use and release throw, report release error, signal use error

2206[info] - bracket works with auto-cancelable run-loops

2207[info] - bracket is stack safe (1)

2208[info] - bracket is stack safe (2)

2209[info] - bracket is stack safe (3)

2210[info] - bracket is stack safe (4)

2211[info] - use is not evaluated on cancel

2212[info] - cancel should wait for already started finalizers on success

2213[info] - cancel should wait for already started finalizers on failure

2214[info] - cancel should wait for already started use finalizers

2215[info] - second cancel should wait for use finalizers

2216[info] - second cancel during acquire should wait for it and finalizers to complete

2217[info] - second cancel during acquire should wait for it and finalizers to complete (non-terminating)

2218[info] - Multiple cancel should not hang

2219[info] - bracket can be canceled while failing to acquire

2220[info] - bracket can be canceled while terminating

2221[info] monix.bio.IOParZipSuite

2222[info] - IO.parZip2 should work if source finishes first

2223[info] - IO.parZip2 should work if other finishes first

2224[info] - IO.parZip2 should cancel both

2225[info] - IO.parZip2 should cancel just the source

2226[info] - IO.parZip2 should cancel just the other

2227[info] - IO.parZip2 should onError from the source before other

2228[info] - IO.parZip2 handle terminal errors from the source before other

2229[info] - IO.parZip2 should onError from the other after the source

2230[info] - IO.parZip2 should handle terminal errors from the other after the source

2231[info] - IO.parZip2 should onError from the other before the source

2232[info] - IO.parZip2 works

2233[info] - IO.map2 works

2234[info] - IO#map2 should protect against user code

2235[info] - IO.map2 runs effects in strict sequence

2236[info] - IO.parMap2 works

2237[info] - IO#parMap2 should protect against user code

2238[info] - IO.parZip3 works

2239[info] - IO#map3 works

2240[info] - IO#parMap3 works

2241[info] - IO.parZip4 works

2242[info] - IO#map4 works

2243[info] - IO#parMap4 works

2244[info] - IO.parZip5 works

2245[info] - IO#map5 works

2246[info] - IO#parMap5 works

2247[info] - IO.parZip6 works

2248[info] - IO#map6 works

2249[info] - IO#parMap6 works

2250[info] monix.bio.TaskConnectionCompositeSuite

2251[info] - cancels Cancelable references

2252[info] - cancels Cancelable references after cancel on assignment

2253[info] - cancels Task references

2254[info] - cancels Task references after cancel on assignment

2255[info] - cancels CancelableF references

2256[info] - cancels CancelableF references after cancel on assignment

2257[info] - addAll

2258[info] - remove Task

2259[info] - remove Cancelable

2260[info] - remove CancelableF

2261[info] monix.bio.TaskBlockingSuite

2262[info] - blocking on future should work

2263[info] - blocking on async

2264[info] - blocking on async.flatMap

2265[info] - blocking with Termination result

2266[info] - IO.eval(throw ex).attempt.runSyncUnsafe

2267[info] - IO.evalTotal(throw ex).onErrorHandle.runSyncUnsafe

2268[info] - IO.suspend(throw ex).attempt.runSyncUnsafe

2269[info] - IO.suspendTotal(throw ex).onErrorHandle.runSyncUnsafe

2270[info] - blocking on memoize

2272[info] - IO.attempt.runSyncUnsafe works

2273[info] monix.bio.TaskConversionsSuite

2274[info] - IO.now(value).to[CIO]

2275[info] - IO.eval(thunk).to[CIO]

2276[info] - IO.eval(thunk).executeAsync.to[CIO]

2277[info] - IO.evalTotal(thunk).to[CIO]

2278[info] - IO.evalTotal(thunk).executeAsync.to[CIO]

2279[info] - IO.raiseError(dummy).to[CIO]

2280[info] - IO.raiseError(dummy).executeAsync.to[CIO]

2281[info] - IO.terminate(dummy).to[CIO]

2282[info] - IO.terminate(dummy).executeAsync.to[CIO]

2283[info] - IO.toAsync converts successful tasks

2284[info] - IO.toAsync converts tasks with typed errors

2285[info] - IO.toAsync converts tasks with terminal errors

2286[info] - IO.toConcurrent converts successful tasks

2287[info] - IO.toConcurrent converts tasks with typed errors

2288[info] - IO.toConcurrent converts tasks with terminal errors

2289[info] - IO.fromEffect(task)) <-> task

2290[info] - IO.fromEffect(task.toAsync[Task]) <-> task

2291[info] - IO.fromEffect(task.toAsync[CIO]) <-> task

2292[info] - IO.fromEffect(task.toAsync[F]) <-> task

2293[info] - IO.fromEffect converts `IO`

2294[info] - IO.fromEffect converts valid custom effects

2295[info] - IO.fromEffect doesn't convert invalid custom effects

2296[info] - IO.fromEffect(task.toConcurrent[IO]) preserves cancellability

2297[info] - IO.fromConcurrentEffect(task) <-> task

2298[info] - IO.fromConcurrentEffect(task.toConcurrent[Task]) <-> task

2299[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) <-> task

2300[info] - IO.fromConcurrentEffect(task.toConcurrent[F]) <-> task

2301[info] - IO.fromConcurrentEffect converts `IO`

2302[info] - IO.fromConcurrentEffect converts valid custom effects

2303[info] - IO.fromConcurrentEffect doesn't convert invalid custom effects

2304[info] - IO.fromConcurrentEffect preserves cancellability of an `IO`

2305[info] - IO.fromConcurrentEffect preserves cancellability of a custom effect

2306[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) preserves cancellability

2307[info] - IO.fromConcurrentEffect(task.toConcurrent[CIO]) preserves cancellability

2308[info] - IO.fromReactivePublisher converts `.onNext` callbacks

2309[info] - IO.fromReactivePublisher converts `.onComplete` callbacks

2310[info] - IO.fromReactivePublisher converts `.onError` callbacks

2311[info] - IO.fromReactivePublisher protects against user errors

2312[info] - IO.fromReactivePublisher is cancelable

2313[info] - IO.fromReactivePublisher <-> Task

2314[info] monix.bio.BIOAppSuite

2315[info] - run works

2316[info] - options are configurable

2317[info] - ConcurrentEffect[Task]

2318[info] monix.bio.TaskLikeConversionsSuite

2319[info] - IO.from(task.to[IO]) <-> task

2320[info] - IO.from converts successful Future

2321[info] - IO.from converts failed Future

2322[info] - IO.from converts successful sync IO

2323[info] - IO.from converts successful async IO

2324[info] - IO.from converts failed sync CIO

2325[info] - IO.from converts failed async IO

2326[info] - IO.from preserves cancellability of an IO

2327[info] - IO.from converts successful Eval

2328[info] - IO.from converts failed Eval

2329[info] - IO.from preserves Eval laziness

2330[info] - IO.from converts successful SyncIO

2331[info] - IO.from converts failed SyncIO

2332[info] - IO.from converts successful Try

2333[info] - IO.from converts failed Try

2334[info] - IO.from converts right Either

2335[info] - IO.from converts left Either

2336[info] - IO.from converts successful custom Effect

2337[info] - IO.from converts failed custom Effect

2338[info] - IO.from converts successful custom ConcurrentEffect

2339[info] - IO.from converts failed custom ConcurrentEffect

2340[info] - IO.from converts Function0

2341[info] - IO.from converts CancelablePromise

2342[info] monix.bio.TaskRaceSuite

2343[info] - IO.raceMany returns fastest success

2344[info] - IO.raceMany returns fastest typed error

2345[info] - IO.raceMany returns fastest terminal error

2346[info] - IO.raceMany returns success that is faster than typed error

2347[info] - IO.raceMany returns success that is faster than terminal error

2348[info] - IO.raceMany returns typed error that is faster than success

2349[info] - IO.raceMany returns typed error that is faster than fatal error

2350[info] - IO.raceMany returns fatal error that is faster than success

2351[info] - IO.raceMany returns fatal error that is faster than typed error

2352[info] - IO.raceMany should allow cancelling all tasks

2353[info] - IO.raceMany should be stack safe for sync values

2354[info] - IO.raceMany should be stack safe for async values

2355[info] - IO.raceMany has a stack safe cancelable

2356[info] - IO#timeout should timeout

2357[info] - IO#timeout should mirror the source in case of success

2358[info] - IO#timeout should mirror the source in case of error

2359[info] - IO#timeout should mirror the source in case of terminal error

2360[info] - IO#timeout should cancel both the source and the timer

2361[info] - IO#timeout with backup should timeout

2362[info] - IO#timeout with backup should timeout with error

2363[info] - IO#timeout with backup should mirror the source in case of success

2364[info] - IO#timeout with backup should mirror the source in case of error

2365[info] - IO#timeout should cancel both the source and the timer

2366[info] - IO#timeout should cancel the backup

2367[info] - IO#timeout should not return the source after timeout

2368[info] - IO#timeout should cancel the source after timeout

2369[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization

2370[info] - IO#timeoutL should evaluate as specified: lazy, with memoization

2371[info] - IO#timeoutL considers time taken to evaluate the duration task

2372[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed

2373[info] - IO.racePair(a,b) should work if a completes first

2374[info] - IO.racePair(a,b) should cancel both

2375[info] - IO.racePair(A,B) should not cancel B if A completes first

2376[info] - IO.racePair(A,B) should not cancel A if B completes first

2377[info] - IO.racePair(A,B) should end both in error if A completes first in error

2378[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error

2379[info] - IO.racePair(A,B) should end both in error if B completes first in error

2380[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error

2381[info] - IO.racePair(A,B) should work if A completes second in error

2382[info] - IO.racePair(A,B) should work if A completes second in terminal error

2383[info] - IO.racePair(A,B) should work if B completes second in error

2384[info] - IO.racePair should be stack safe, take 1

2385[info] - IO.racePair should be stack safe, take 2

2386[info] - IO.racePair has a stack safe cancelable

2387[info] - IO.race(a, b) should work if a completes first

2388[info] - IO.race(a, b) should work if b completes first

2389[info] - IO.race(a, b) should cancel both

2390[info] - IO.race(a, b) should end both in error if `a` completes first in error

2391[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error

2392[info] - IO.race(a, b) should end both in error if `b` completes first in error

2393[info] - IO.race(a, b) should end both in error if `b` completes first in error

2394[info] - IO.race(a, b) should work if `a` completes in typed error

2395[info] - IO.race(a, b) should work if `a` completes in unexpected error

2396[info] - IO.race(a, b) should work if `b` completes in typed error

2397[info] - IO.race(a, b) should work if `b` completes in unexpected error

2398[info] - IO.race should be stack safe, take 1

2399[info] - IO.race should be stack safe, take 2

2400[info] - Task.race has a stack safe cancelable

2401[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite

2402[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2403[info] - CoflatMap[Task].coflatMap.coflatMap identity

2404[info] - CoflatMap[Task].coflatMap.coflatten coherence

2405[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2406[info] - CoflatMap[Task].coflatMap.covariant composition

2407[info] - CoflatMap[Task].coflatMap.covariant identity

2408[info] - CoflatMap[Task].coflatMap.invariant composition

2409[info] - CoflatMap[Task].coflatMap.invariant identity

2410[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2411[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2412[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2413[info] - Concurrent[Task].concurrent.ap consistent with product + map

2414[info] - Concurrent[Task].concurrent.applicative homomorphism

2415[info] - Concurrent[Task].concurrent.applicative identity

2416[info] - Concurrent[Task].concurrent.applicative interchange

2417[info] - Concurrent[Task].concurrent.applicative map

2418[info] - Concurrent[Task].concurrent.applicative unit

2419[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2420[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2421[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2422[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2423[info] - Concurrent[Task].concurrent.applicativeError handle

2424[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2425[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2426[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2427[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2428[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2429[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2430[info] - Concurrent[Task].concurrent.applicativeError handleWith

2431[info] - Concurrent[Task].concurrent.applicativeError onError pure

2432[info] - Concurrent[Task].concurrent.applicativeError onError raise

2433[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2434[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2435[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2436[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2437[info] - Concurrent[Task].concurrent.apply composition

2438[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2439[info] - Concurrent[Task].concurrent.async cancelable coherence

2440[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2441[info] - Concurrent[Task].concurrent.async left is raiseError

2442[info] - Concurrent[Task].concurrent.async right is pure

2443[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2444[info] - Concurrent[Task].concurrent.bind suspends evaluation

2445[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2446[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2447[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2448[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2449[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2450[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2451[info] - Concurrent[Task].concurrent.covariant composition

2452[info] - Concurrent[Task].concurrent.covariant identity

2453[info] - Concurrent[Task].concurrent.delay constant is pure

2454[info] - Concurrent[Task].concurrent.flatMap associativity

2455[info] - Concurrent[Task].concurrent.flatMap consistent apply

2456[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2457[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2458[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2459[info] - Concurrent[Task].concurrent.invariant composition

2460[info] - Concurrent[Task].concurrent.invariant identity

2461[info] - Concurrent[Task].concurrent.join is idempotent

2462[info] - Concurrent[Task].concurrent.map flatMap coherence

2463[info] - Concurrent[Task].concurrent.map suspends evaluation

2464[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2465[info] - Concurrent[Task].concurrent.map2/product-map consistency

2466[info] - Concurrent[Task].concurrent.monad left identity

2467[info] - Concurrent[Task].concurrent.monad right identity

2468[info] - Concurrent[Task].concurrent.monadError ensure consistency

2469[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2470[info] - Concurrent[Task].concurrent.monadError left zero

2471[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2472[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2473[info] - Concurrent[Task].concurrent.monoidal left identity

2474[info] - Concurrent[Task].concurrent.monoidal right identity

2475[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2476[info] - Concurrent[Task].concurrent.never is derived from async

2477[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2478[info] - Concurrent[Task].concurrent.productL consistent map2

2479[info] - Concurrent[Task].concurrent.productR consistent map2

2480[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2481[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2482[info] - Concurrent[Task].concurrent.race cancels both

2483[info] - Concurrent[Task].concurrent.race cancels loser

2484[info] - Concurrent[Task].concurrent.race mirrors left winner

2485[info] - Concurrent[Task].concurrent.race mirrors right winner

2486[info] - Concurrent[Task].concurrent.racePair can join left

2487[info] - Concurrent[Task].concurrent.racePair can join right

2488[info] - Concurrent[Task].concurrent.racePair cancels both

2489[info] - Concurrent[Task].concurrent.racePair cancels loser

2490[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2491[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2492[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2493[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2494[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2495[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2496[info] - Concurrent[Task].concurrent.semigroupal associativity

2497[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2498[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2499[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2500[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2501[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2502[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2503[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2504[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2505[info] - Concurrent[Task].concurrent.start then join is identity

2506[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2507[info] - Concurrent[Task].concurrent.suspend constant is pure join

2508[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2509[info] - Concurrent[Task].concurrent.tailRecM stack safety

2510[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2511[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2512[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2513[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2514[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2515[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2516[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2517[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2518[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2519[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2520[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2521[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2522[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2523[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2524[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2525[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2526[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2527[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2528[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2529[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2530[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2531[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2532[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2533[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2534[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2535[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2536[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2537[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2538[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2539[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2540[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2541[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2542[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2543[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2544[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2545[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2546[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2547[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2548[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2549[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2550[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2551[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2552[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2553[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2554[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2555[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2556[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2557[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2558[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2559[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2560[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2561[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2562[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2563[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2564[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2565[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2566[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2567[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2568[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2569[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2570[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2571[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2572[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2573[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2574[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2575[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2576[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2577[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2578[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2579[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2580[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2581[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2582[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2583[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2584[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2585[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2586[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2587[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2588[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2589[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2590[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2591[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2592[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2593[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2594[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2595[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2596[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2597[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2598[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2599[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2600[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2601[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2602[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2603[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2604[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2605[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2606[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2607[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2608[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2609[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2610[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2611[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2612[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2613[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2614[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2615[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2616[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2617[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2618[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2619[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2620[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2621[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2622[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2623[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2624[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2625[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2626[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2627[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2628[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2629[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2630[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2631[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2632[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2633[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2634[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2635[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2636[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2637[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2638[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2639[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2640[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2641[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2642[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2643[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2644[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2645[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2646[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2647[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2648[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2649[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2650[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2651[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2652[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2653[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2654[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2655[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2656[info] - Monoid[IO[String, Int]].monoid.associative

2657[info] - Monoid[IO[String, Int]].monoid.collect0

2658[info] - Monoid[IO[String, Int]].monoid.combine all

2659[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2660[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2661[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2662[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2663[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2664[info] - Monoid[IO[String, Int]].monoid.is id

2665[info] - Monoid[IO[String, Int]].monoid.left identity

2666[info] - Monoid[IO[String, Int]].monoid.repeat0

2667[info] - Monoid[IO[String, Int]].monoid.repeat1

2668[info] - Monoid[IO[String, Int]].monoid.repeat2

2669[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2670[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2671[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2672[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2673[info] - Monoid[IO[String, Int]].monoid.right identity

2674[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2675[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2676[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2677[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2678[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2679[info] monix.bio.TypeClassLawsForTaskSuite

2680[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2681[info] - CoflatMap[Task].coflatMap.coflatMap identity

2682[info] - CoflatMap[Task].coflatMap.coflatten coherence

2683[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2684[info] - CoflatMap[Task].coflatMap.covariant composition

2685[info] - CoflatMap[Task].coflatMap.covariant identity

2686[info] - CoflatMap[Task].coflatMap.invariant composition

2687[info] - CoflatMap[Task].coflatMap.invariant identity

2688[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2689[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2690[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2691[info] - Concurrent[Task].concurrent.ap consistent with product + map

2692[info] - Concurrent[Task].concurrent.applicative homomorphism

2693[info] - Concurrent[Task].concurrent.applicative identity

2694[info] - Concurrent[Task].concurrent.applicative interchange

2695[info] - Concurrent[Task].concurrent.applicative map

2696[info] - Concurrent[Task].concurrent.applicative unit

2697[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2698[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2699[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2700[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2701[info] - Concurrent[Task].concurrent.applicativeError handle

2702[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2703[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2704[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2705[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2706[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2707[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2708[info] - Concurrent[Task].concurrent.applicativeError handleWith

2709[info] - Concurrent[Task].concurrent.applicativeError onError pure

2710[info] - Concurrent[Task].concurrent.applicativeError onError raise

2711[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2712[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2713[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2714[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2715[info] - Concurrent[Task].concurrent.apply composition

2716[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2717[info] - Concurrent[Task].concurrent.async cancelable coherence

2718[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2719[info] - Concurrent[Task].concurrent.async left is raiseError

2720[info] - Concurrent[Task].concurrent.async right is pure

2721[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2722[info] - Concurrent[Task].concurrent.bind suspends evaluation

2723[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2724[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2725[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2726[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2727[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2728[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2729[info] - Concurrent[Task].concurrent.covariant composition

2730[info] - Concurrent[Task].concurrent.covariant identity

2731[info] - Concurrent[Task].concurrent.delay constant is pure

2732[info] - Concurrent[Task].concurrent.flatMap associativity

2733[info] - Concurrent[Task].concurrent.flatMap consistent apply

2734[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2735[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2736[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2737[info] - Concurrent[Task].concurrent.invariant composition

2738[info] - Concurrent[Task].concurrent.invariant identity

2739[info] - Concurrent[Task].concurrent.join is idempotent

2740[info] - Concurrent[Task].concurrent.map flatMap coherence

2741[info] - Concurrent[Task].concurrent.map suspends evaluation

2742[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2743[info] - Concurrent[Task].concurrent.map2/product-map consistency

2744[info] - Concurrent[Task].concurrent.monad left identity

2745[info] - Concurrent[Task].concurrent.monad right identity

2746[info] - Concurrent[Task].concurrent.monadError ensure consistency

2747[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2748[info] - Concurrent[Task].concurrent.monadError left zero

2749[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2750[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2751[info] - Concurrent[Task].concurrent.monoidal left identity

2752[info] - Concurrent[Task].concurrent.monoidal right identity

2753[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2754[info] - Concurrent[Task].concurrent.never is derived from async

2755[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2756[info] - Concurrent[Task].concurrent.productL consistent map2

2757[info] - Concurrent[Task].concurrent.productR consistent map2

2758[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2759[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2760[info] - Concurrent[Task].concurrent.race cancels both

2761[info] - Concurrent[Task].concurrent.race cancels loser

2762[info] - Concurrent[Task].concurrent.race mirrors left winner

2763[info] - Concurrent[Task].concurrent.race mirrors right winner

2764[info] - Concurrent[Task].concurrent.racePair can join left

2765[info] - Concurrent[Task].concurrent.racePair can join right

2766[info] - Concurrent[Task].concurrent.racePair cancels both

2767[info] - Concurrent[Task].concurrent.racePair cancels loser

2768[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2769[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2770[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2771[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2772[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2773[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2774[info] - Concurrent[Task].concurrent.semigroupal associativity

2775[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2776[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2777[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2778[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2779[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2780[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2781[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2782[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2783[info] - Concurrent[Task].concurrent.start then join is identity

2784[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2785[info] - Concurrent[Task].concurrent.suspend constant is pure join

2786[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2787[info] - Concurrent[Task].concurrent.tailRecM stack safety

2788[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2789[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2790[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2791[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2792[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2793[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2794[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2795[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2796[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2797[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2798[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2799[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2800[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2801[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2802[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2803[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2804[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2805[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2806[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2807[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2808[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2809[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2810[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2811[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2812[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2813[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2814[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2815[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2816[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2817[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2818[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2819[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2820[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2821[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2822[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2823[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2824[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2825[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2826[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2827[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2828[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2829[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2830[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2831[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2832[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2833[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2834[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2835[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2836[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2837[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2838[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2839[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2840[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2841[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2842[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2843[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2844[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2845[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2846[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2847[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2848[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2849[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2850[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2851[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2852[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2853[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2854[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2855[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2856[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2857[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2858[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2859[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2860[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2861[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2862[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2863[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2864[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2865[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2866[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2867[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2868[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2869[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2870[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2871[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2872[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2873[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2874[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2875[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2876[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2877[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2878[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2879[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2880[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2881[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2882[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2883[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2884[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2885[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2886[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2887[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2888[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2889[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2890[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2891[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2892[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2893[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2894[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2895[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2896[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2897[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2898[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2899[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2900[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2901[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2902[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2903[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2904[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2905[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2906[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2907[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2908[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2909[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2910[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2911[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2912[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2913[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2914[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2915[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2916[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2917[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2918[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2919[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2920[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2921[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2922[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2923[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2924[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2925[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2926[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2927[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2928[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2929[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2930[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2931[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2932[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2933[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2934[info] - Monoid[IO[String, Int]].monoid.associative

2935[info] - Monoid[IO[String, Int]].monoid.collect0

2936[info] - Monoid[IO[String, Int]].monoid.combine all

2937[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2938[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2939[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2940[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2941[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2942[info] - Monoid[IO[String, Int]].monoid.is id

2943[info] - Monoid[IO[String, Int]].monoid.left identity

2944[info] - Monoid[IO[String, Int]].monoid.repeat0

2945[info] - Monoid[IO[String, Int]].monoid.repeat1

2946[info] - Monoid[IO[String, Int]].monoid.repeat2

2947[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2948[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2949[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2950[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2951[info] - Monoid[IO[String, Int]].monoid.right identity

2952[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2953[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2954[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2955[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2956[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2958************************

2959Build summary:

2960[{

2961 "module": "monix-bio",

2962 "compile": {"status": "ok", "tookMs": 18991, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2963 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2964 "test-compile": {"status": "ok", "tookMs": 34269, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2965 "test": {"status": "ok", "tookMs": 28998, "passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607, "byFramework": [{"framework": "unknown", "stats": {"passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607}}]},

2966 "publish": {"status": "skipped", "tookMs": 0},

2967 "metadata": {

2968 "crossScalaVersions": ["2.12.13", "2.13.5", "3.0.0"]

2969}

2970}]

2971************************

2972[success] Total time: 95 s (0:01:35.0), completed Dec 4, 2025, 3:50:12 PM

2973[0JChecking patch project/plugins.sbt...

2974Checking patch project/build.properties...

2975Checking patch build.sbt...

2976Applied patch project/plugins.sbt cleanly.

2977Applied patch project/build.properties cleanly.

2978Applied patch build.sbt cleanly.