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

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

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

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

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

60"++3.8.0-RC2 -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-RC2 """{"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.652s.

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

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

196OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC2 in coreJVM/crossScalaVersions

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

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

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

202[info] Switching Scala version on:

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

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

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

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

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

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 Nov 28, 2025, 12:15:33 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-RC2/classes ...

246[info] done compiling

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

250[info] done compiling

251[info] monix.bio.TaskCallbackSuite

252[info] - onValue should invoke onSuccess

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

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

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

256[info] - contramap should pipe onError

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

258[info] - BiCallback.fromPromise (success)

259[info] - BiCallback.fromPromise (failure)

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

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

262[info] - BiCallback.empty reports errors

263[info] - BiCallback.empty reports terminal errors

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

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

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

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

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

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

270[info] - fromAttempt success

271[info] - fromAttempt error

272[info] - fromAttempt termination

273[info] monix.bio.IODoOnFinishSuite

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

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

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

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

278[info] monix.bio.TaskFlatMapSuite

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

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

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

282[info] - redeemWith derives flatMap

283[info] - redeemWith derives onErrorHandleWith

284[info] - redeem derives map . onErrorHandle

285[info] - redeem derives onErrorHandle

286[info] - redeemWith can recover

287[info] - redeem can recover

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

289[info] - flatMapLoop enables loops

290[info] monix.bio.TaskExecuteWithOptionsSuite

291[info] - executeWithOptions works

292[info] - local.write.executeWithOptions

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

294[info] monix.bio.TaskStartSuite

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

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

297[info] - task.start is stack safe

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

299[info] - task.start is stack safe

300[info] - task.start executes asynchronously

301[info] monix.bio.TaskTerminationSuite

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

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

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

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

306[info] - IO#redeemCauseWith derives flatMap

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

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

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

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

311Hello World!

312Cancelling!

313Received: $value

314Hello!

315Hello!

316Success: 42

317[info] monix.bio.IODoctest

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

402[info] monix.bio.TaskBimapSuite

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

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

405[info] monix.bio.TaskFromFutureSuite

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

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

408[info] - Task.fromFuture should work onSuccess

409[info] - Task.fromFuture should work onError

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

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

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

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

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

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

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

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

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

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

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

421[info] monix.bio.TaskEffectInstanceSuite

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

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

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

425[info] monix.bio.TaskConnectionCompositeSuite

426[info] - cancels Cancelable references

427[info] - cancels Cancelable references after cancel on assignment

428[info] - cancels Task references

429[info] - cancels Task references after cancel on assignment

430[info] - cancels CancelableF references

431[info] - cancels CancelableF references after cancel on assignment

432[info] - addAll

433[info] - remove Task

434[info] - remove Cancelable

435[info] - remove CancelableF

436[info] monix.bio.TaskExecuteAsyncSuite

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

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

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

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

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

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

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

444[info] monix.bio.TaskAsyncSuite

445[info] - IO.never should never complete

446[info] - IO.async should execute

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

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

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

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

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

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

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

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

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

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

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

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

459[info] monix.bio.TaskParSequenceUnorderedSuite

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

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

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

463[info] - IO.parSequenceUnordered should be canceled

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

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

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

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

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

469[info] - IO.parSequenceUnordered runAsync multiple times

470[info] monix.bio.TaskToFutureSuite

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

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

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

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

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

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

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

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

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

480[info] - Task.fromFuture async result

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

482[info] - Task.deferFuture async result

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

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

485[info] - Task.deferFutureAction async result

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

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

488[info] - Task.fromFuture(cancelable)

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

490[info] - Task.deferFuture(cancelable)

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

492[info] - Task.deferFutureAction(cancelable)

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

494Executing...

495Received: $str

496Executing...

497Executing...

498Finished via exit code: $exitCode

499Resources were released!

500Executing...

501Received: $str

502[info] monix.bio.TaskAsyncAutoShiftJVMSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

551[info] monix.bio.TaskOptionsSuite

552[info] - change options with future

553[info] - change options with callback

554[info] monix.bio.TaskParTraverseNSuite

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

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

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

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

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

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

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

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

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

565[info] - IO.parTraverseN should be cancelable

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

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

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

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

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

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

572[info] monix.bio.TaskConversionsKSuite

573[info] - Task.liftTo[CIO]

574[info] - Task.liftToAsync[IO]

575[info] - Task.liftToConcurrent[IO]

576[info] - Task.liftFrom[IO]

577[info] - Task.liftFromEffect[IO]

578[info] - Task.liftFromConcurrentEffect[IO]

579Hello!

580[info] monix.bio.TaskParSequenceSuite

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

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

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

584[info] - IO.parSequence should be canceled

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

586[info] - IO.parSequence runAsync multiple times

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

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

589[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

861[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1090[info] monix.bio.IOLocalSuite

1091[info] - IOLocal.apply

1092[info] - IOLocal.wrap

1093[info] - IOLocal!.bind

1094[info] - IOLocal!.bindL

1095[info] - IOLocal!.bindClear

1096[info] - IOLocal canceled

1097[info] - IOLocal!.local

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

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

1100[info] - IOLocal should work with bracket

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

1102[info] - IOLocal interop with future via deferFutureAction

1103[info] - IOLocal.bind scoping works

1104[info] - IOLocal.bind actually isolates reads

1105[info] - IOLocal.isolate with ConcurrentChannel

1106[info] monix.bio.TaskAsyncBoundarySuite

1107[info] - IO.asyncBoundary should work

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

1109[info] - IO.asyncBoundary should preserve locals

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

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

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

1113value1: 0

1114value2: 100

1115value3: 400

1116value4: 100

1117value5: 0

1118[info] monix.bio.IOLocalDoctest

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

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

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

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

1123[info] monix.bio.TaskNowSuite

1124[info] - IO.now should work synchronously

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

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

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

1128[info] - IO.raiseError should work synchronously

1129[info] - IO.terminate should work synchronously

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

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

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

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

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

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

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

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

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

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

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

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

1142[info] - IO.now.runSyncStep

1143[info] - IO.raiseError.runSyncStep

1144[info] monix.bio.IOLocalJVMSuite

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

1146[info] - locals get transported with executeWithModel

1147[info] - locals get transported with executeWithOptions

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

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

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

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

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

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

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

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

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

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

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

1159[info] - Task.eval.runToFuture isolates but preserves context for Future continuation

1160[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation on a single thread

1161[info] - Task.eval.runToFuture continuations keep isolated context in longer continuations

1162[info] - Task.eval.runToFuture can isolate future continuations

1163[info] - Task.eval.runToFuture can isolate future continuations on failure

1164[info] - Task.runToFuture resulting future can be reused

1165[info] - Task.eval.runToFuture is isolated from outside changes

1166[info] monix.bio.TaskTimedSuite

1167[info] - measure tasks with no errors

1168[info] - not measure tasks with typed errors

1169[info] - not measure tasks with terminal errors

1170[info] - measure tasks with typed errors followed by `.attempt`

1171[info] - not measure tasks with terminal errors followed by `.attempt`

1172[info] - stack safety

1173[info] monix.bio.TaskCallbackSafetySuite

1174[info] - IO.async's callback can be called multiple times

1175[info] - IO.async0's callback can be called multiple times

1176[info] - IO.asyncF's callback can be called multiple times

1177[info] - IO.cancelable's callback can be called multiple times

1178[info] - IO.cancelable0's callback can be called multiple times

1179[info] - IO.async's register throwing is signaled as error

1180[info] - IO.async0's register throwing is signaled as error

1181[info] - IO.asyncF's register throwing is signaled as error (1)

1182[info] - IO.asyncF's register throwing is signaled as error (2)

1183[info] - IO.cancelable's register throwing is signaled as error

1184[info] - IO.cancelable0's register throwing is signaled as error

1185[info] - IO.async's register throwing, after result, is reported

1186[info] - IO.async0's register throwing, after result, is reported

1187[info] - IO.asyncF's register throwing, after result, is reported (1)

1188[info] - IO.asyncF's register throwing, after result, is reported (2)

1189[info] - IO.cancelable's register throwing, after result, is reported

1190[info] - IO.cancelable0's register throwing, after result, is reported

1191[info] monix.bio.TaskDeferActionSuite

1192[info] - IO.deferAction works

1193[info] - IO.deferAction works for failed tasks

1194[info] - IO.deferAction protects against user error

1195[info] - IO.deferAction should properly cast errors

1196[info] - IO.deferAction is stack safe

1197[info] - IO.deferAction(local.write) works

1198[info] monix.bio.TaskTraverseSuite

1199[info] - IO.traverse should not execute in parallel

1200[info] - IO.traverse should onError if one of the tasks terminates in error

1201[info] - IO.traverse should onError if one of the tasks terminates in error

1202[info] - IO.traverse should be canceled

1203[info] monix.bio.TaskEvalAsyncSuite

1204[info] - IO.evalAsync should work, on different thread

1205[info] - IO.evalAsync should protect against user code errors

1206[info] - UIO.evalAsync should protect against user code errors

1207[info] - IO.evalAsync is equivalent with IO.eval

1208[info] - IO.evalAsync is equivalent with IO.evalOnce on first run

1209[info] - IO.evalAsync.flatMap should protect against user code

1210[info] - IO.evalAsync should be tail recursive

1211[info] - IO.evalAsync.flatten is equivalent with flatMap

1212[info] - IO.evalAsync.coeval

1213[info] monix.bio.IOParZipSuite

1214[info] - IO.parZip2 should work if source finishes first

1215[info] - IO.parZip2 should work if other finishes first

1216[info] - IO.parZip2 should cancel both

1217[info] - IO.parZip2 should cancel just the source

1218[info] - IO.parZip2 should cancel just the other

1219[info] - IO.parZip2 should onError from the source before other

1220[info] - IO.parZip2 handle terminal errors from the source before other

1221[info] - IO.parZip2 should onError from the other after the source

1222[info] - IO.parZip2 should handle terminal errors from the other after the source

1223[info] - IO.parZip2 should onError from the other before the source

1224[info] - IO.parZip2 works

1225[info] - IO.map2 works

1226[info] - IO#map2 should protect against user code

1227[info] - IO.map2 runs effects in strict sequence

1228[info] - IO.parMap2 works

1229[info] - IO#parMap2 should protect against user code

1230[info] - IO.parZip3 works

1231[info] - IO#map3 works

1232[info] - IO#parMap3 works

1233[info] - IO.parZip4 works

1234[info] - IO#map4 works

1235[info] - IO#parMap4 works

1236[info] - IO.parZip5 works

1237[info] - IO#map5 works

1238[info] - IO#parMap5 works

1239[info] - IO.parZip6 works

1240[info] - IO#map6 works

1241[info] - IO#parMap6 works

1242[info] monix.bio.TaskParTraverseSuite

1243[info] - IO.parTraverse should execute in parallel for async tasks

1244[info] - IO.parTraverse should onError if one of the tasks terminates in error

1245[info] - IO.parTraverse should onTerminate if one of the tasks terminates in unexpected error

1246[info] - IO.parTraverse should be canceled

1247[info] - IO.parTraverse should be stack safe for synchronous tasks

1248[info] - IO.parTraverse runAsync multiple times

1250[info] monix.bio.BIOAppSuite

1251[info] - run works

1252[info] - options are configurable

1253[info] - ConcurrentEffect[Task]

1254[info] monix.bio.TaskBlockingSuite

1255[info] - blocking on future should work

1256[info] - blocking on async

1257[info] - blocking on async.flatMap

1258[info] - blocking with Termination result

1259[info] - IO.eval(throw ex).attempt.runSyncUnsafe

1260[info] - IO.evalTotal(throw ex).onErrorHandle.runSyncUnsafe

1261[info] - IO.suspend(throw ex).attempt.runSyncUnsafe

1262[info] - IO.suspendTotal(throw ex).onErrorHandle.runSyncUnsafe

1263[info] - blocking on memoize

1265[info] - IO.attempt.runSyncUnsafe works

1266[info] monix.bio.TaskConnectionSuite

1267[info] - initial push

1268[info] - cancels Task after being canceled

1269[info] - cancels Cancelable after being canceled

1270[info] - cancels CancelableF after being canceled

1271[info] - push two, pop one

1272[info] - cancel the second time is a no-op

1273[info] - push two, pop two

1274[info] - push(Cancelable)

1275[info] - push(Cancelable) then pop

1276[info] - push(CancelToken)

1277[info] - push(CancelToken) then pop

1278[info] - pop when self is empty

1279[info] - pop when self is canceled

1280[info] - cancel mixture

1281[info] - cancel mixture after being cancelled

1282[info] - tryReactive

1283[info] - toCancelable

1284[info] - uncancelable ref is shared

1285[info] - uncancelable ops

1286[info] - throwing error in Task on cancel all

1287[info] - throwing multiple errors in Tasks on cancel all

1288[info] - throwing error in Task after cancel

1289[info] - throwing error in Cancelable on cancel all

1290[info] - throwing multiple errors in Cancelables on cancel all

1291[info] - throwing error in Cancelable after cancel

1292[info] monix.bio.TaskErrorSuite

1293[info] - IO.attempt should expose typed error

1294[info] - IO.attempt should not expose unexpected error

1295[info] - IO.attempt should work for successful values

1296[info] - IO.rethrow should turn Left to typed error

1297[info] - IO.rethrow should turn Right to success value

1298[info] - IO.failed should expose typed error

1299[info] - IO.failed should fail for unexpected error

1300[info] - IO.failed should fail for successful values

1301[info] - IO#onErrorRecover should mirror source on success

1302[info] - IO#onErrorRecover should recover typed error

1303[info] - IO#onErrorRecover should not recover unexpected error

1304[info] - IO#onErrorRecover should protect against user code

1305[info] - IO#onErrorHandle should mirror source on success

1306[info] - IO#onErrorHandle should recover typed error

1307[info] - IO#onErrorHandle should not recover unexpected error

1308[info] - IO#onErrorHandle should protect against user code

1309[info] - IO.onErrorFallbackTo should mirror source onSuccess

1310[info] - IO.onErrorFallbackTo should fallback to backup onError

1311[info] - IO.onErrorFallbackTo should not fallback to backup onTermination

1312[info] - IO.onErrorFallbackTo should protect against user code

1313[info] - IO.onErrorFallbackTo should be cancelable if the ExecutionModel allows it

1314[info] - IO.onErrorRestart should mirror the source onSuccess

1315[info] - IO.onErrorRestart should retry onError

1316[info] - IO.onErrorRestart should emit onError after max retries

1317[info] - IO.onErrorRestart should be cancelable if ExecutionModel permits

1318[info] - IO.onErrorRestart should not restart on terminate error

1319[info] - IO.onErrorRestartIf should mirror the source onSuccess

1320[info] - IO.onErrorRestartIf should retry onError

1321[info] - IO.onErrorRestartIf should emit onError

1322[info] - IO.onErrorRestartIf should be cancelable if ExecutionModel permits

1323[info] - IO.onErrorRestartIf should not restart on terminate error

1324[info] - IO.onErrorRestartIf should restart on typed error

1325[info] - IO#onErrorRecoverWith should mirror source on success

1326[info] - IO#onErrorRecoverWith should recover

1331[info] - IO#onErrorRecoverWith should protect against user code

1332[info] - IO#onErrorRecoverWith has a cancelable fallback

1333[info] - IO#onErrorRecover should emit error if not matches

1334[info] - IO#onErrorRecoverWith should emit error if not matches

1335[info] - IO.eval.flatMap.redeemCauseWith should work

1336[info] - IO.evalAsync.flatMap.redeemCauseWith should work

1337[info] - IO.now.onErrorRecoverWith should be stack safe

1338[info] - onErrorRecoverWith should be stack safe for loop with executeAsync boundaries

1339[info] - Task.onErrorRestartLoop works for success

1340[info] - Task.onErrorRestartLoop can throw different error

1341[info] - Task.onErrorRestartLoop can rethrow

1342[info] monix.bio.TaskMapBothSuite

1343[info] - if both tasks are synchronous, then mapBoth forks

1344[info] - sum two async tasks

1345[info] - sum two synchronous tasks

1346[info] - should be stack-safe for synchronous tasks

1347[info] - should be stack-safe for asynchronous tasks

1348[info] - should have a stack safe cancelable

1349[info] - sum random synchronous tasks

1350[info] - sum random asynchronous tasks

1351[info] - both task can fail with error

1352[info] - both task can fail with terminal error

1353[info] monix.bio.TaskDoOnCancelSuite

1354[info] - doOnCancel should normally mirror the source

1355[info] - doOnCancel should mirror failed sources

1356[info] - doOnCancel should mirror terminated sources

1357[info] - doOnCancel should cancel delayResult #1

1358[info] - doOnCancel should cancel delayResult #2

1359[info] - doOnCancel should cancel delayResult #3

1360[info] - doOnCancel should cancel delayExecution #1

1361[info] - doOnCancel should cancel delayExecution #2

1362[info] - doOnCancel is stack safe in flatMap loops

1363[info] - local.write.doOnCancel works

1364[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite

1365[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1366[info] - CoflatMap[Task].coflatMap.coflatMap identity

1367[info] - CoflatMap[Task].coflatMap.coflatten coherence

1368[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1369[info] - CoflatMap[Task].coflatMap.covariant composition

1370[info] - CoflatMap[Task].coflatMap.covariant identity

1371[info] - CoflatMap[Task].coflatMap.invariant composition

1372[info] - CoflatMap[Task].coflatMap.invariant identity

1373[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1374[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1375[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1376[info] - Concurrent[Task].concurrent.ap consistent with product + map

1377[info] - Concurrent[Task].concurrent.applicative homomorphism

1378[info] - Concurrent[Task].concurrent.applicative identity

1379[info] - Concurrent[Task].concurrent.applicative interchange

1380[info] - Concurrent[Task].concurrent.applicative map

1381[info] - Concurrent[Task].concurrent.applicative unit

1382[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1383[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1384[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1385[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1386[info] - Concurrent[Task].concurrent.applicativeError handle

1387[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1388[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1389[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1390[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1391[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

1392[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

1393[info] - Concurrent[Task].concurrent.applicativeError handleWith

1394[info] - Concurrent[Task].concurrent.applicativeError onError pure

1395[info] - Concurrent[Task].concurrent.applicativeError onError raise

1396[info] - Concurrent[Task].concurrent.applicativeError pure attempt

1397[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

1398[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

1399[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

1400[info] - Concurrent[Task].concurrent.apply composition

1401[info] - Concurrent[Task].concurrent.async can be derived from asyncF

1402[info] - Concurrent[Task].concurrent.async cancelable coherence

1403[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

1404[info] - Concurrent[Task].concurrent.async left is raiseError

1405[info] - Concurrent[Task].concurrent.async right is pure

1406[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

1407[info] - Concurrent[Task].concurrent.bind suspends evaluation

1408[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

1409[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

1410[info] - Concurrent[Task].concurrent.bracket release is called on cancel

1411[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

1412[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

1413[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1414[info] - Concurrent[Task].concurrent.covariant composition

1415[info] - Concurrent[Task].concurrent.covariant identity

1416[info] - Concurrent[Task].concurrent.delay constant is pure

1417[info] - Concurrent[Task].concurrent.flatMap associativity

1418[info] - Concurrent[Task].concurrent.flatMap consistent apply

1419[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

1420[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

1421[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

1422[info] - Concurrent[Task].concurrent.invariant composition

1423[info] - Concurrent[Task].concurrent.invariant identity

1424[info] - Concurrent[Task].concurrent.join is idempotent

1425[info] - Concurrent[Task].concurrent.map flatMap coherence

1426[info] - Concurrent[Task].concurrent.map suspends evaluation

1427[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

1428[info] - Concurrent[Task].concurrent.map2/product-map consistency

1429[info] - Concurrent[Task].concurrent.monad left identity

1430[info] - Concurrent[Task].concurrent.monad right identity

1431[info] - Concurrent[Task].concurrent.monadError ensure consistency

1432[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

1433[info] - Concurrent[Task].concurrent.monadError left zero

1434[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

1435[info] - Concurrent[Task].concurrent.monadError rethrow attempt

1436[info] - Concurrent[Task].concurrent.monoidal left identity

1437[info] - Concurrent[Task].concurrent.monoidal right identity

1438[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

1439[info] - Concurrent[Task].concurrent.never is derived from async

1440[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

1441[info] - Concurrent[Task].concurrent.productL consistent map2

1442[info] - Concurrent[Task].concurrent.productR consistent map2

1443[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

1444[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

1445[info] - Concurrent[Task].concurrent.race cancels both

1446[info] - Concurrent[Task].concurrent.race cancels loser

1447[info] - Concurrent[Task].concurrent.race mirrors left winner

1448[info] - Concurrent[Task].concurrent.race mirrors right winner

1449[info] - Concurrent[Task].concurrent.racePair can join left

1450[info] - Concurrent[Task].concurrent.racePair can join right

1451[info] - Concurrent[Task].concurrent.racePair cancels both

1452[info] - Concurrent[Task].concurrent.racePair cancels loser

1453[info] - Concurrent[Task].concurrent.racePair mirrors left winner

1454[info] - Concurrent[Task].concurrent.racePair mirrors right winner

1455[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

1456[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

1457[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

1458[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

1459[info] - Concurrent[Task].concurrent.semigroupal associativity

1460[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

1461[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

1462[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

1463[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

1464[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

1465[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

1466[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

1467[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

1468[info] - Concurrent[Task].concurrent.start then join is identity

1469[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

1470[info] - Concurrent[Task].concurrent.suspend constant is pure join

1471[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

1472[info] - Concurrent[Task].concurrent.tailRecM stack safety

1473[info] - Concurrent[Task].concurrent.throw in delay is raiseError

1474[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

1475[info] - Concurrent[Task].concurrent.uncancelable mirrors source

1476[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

1477[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

1478[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

1479[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

1480[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

1481[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

1482[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

1483[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

1484[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

1485[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

1486[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

1487[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

1488[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

1489[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

1490[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

1491[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

1492[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

1493[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

1494[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

1495[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

1496[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

1497[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

1498[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

1499[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

1500[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

1501[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

1502[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

1503[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

1504[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

1505[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

1506[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

1507[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

1508[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

1509[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

1510[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

1511[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

1512[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

1513[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

1514[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

1515[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

1516[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

1517[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

1518[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

1519[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1520[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

1521[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

1522[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

1523[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

1524[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

1525[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

1526[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

1527[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

1528[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

1529[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

1530[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

1531[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

1532[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

1533[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

1534[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

1535[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

1536[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

1537[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

1538[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

1539[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

1540[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

1541[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

1542[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

1543[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

1544[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

1545[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

1546[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

1547[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

1548[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

1549[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

1550[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

1551[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

1552[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

1553[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

1554[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

1555[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

1556[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

1557[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

1558[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

1559[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

1560[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

1561[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

1562[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

1563[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

1564[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

1565[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

1566[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

1567[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

1568[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

1569[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

1570[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

1571[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

1572[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

1573[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

1574[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

1575[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

1576[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

1577[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

1578[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

1579[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

1580[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

1581[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

1582[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

1583[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

1584[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

1585[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

1586[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

1587[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

1588[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

1589[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

1590[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

1591[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

1592[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

1593[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

1594[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

1595[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

1596[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

1597[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

1598[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

1599[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

1600[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

1601[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

1602[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

1603[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

1604[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

1605[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

1606[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

1607[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

1608[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

1609[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

1610[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

1611[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

1612[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

1613[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

1614[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

1615[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

1616[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

1617[info] - Parallel[IO, IO.Par].parallel.parallel round trip

1618[info] - Parallel[IO, IO.Par].parallel.sequential round trip

1619[info] - Monoid[IO[String, Int]].monoid.associative

1620[info] - Monoid[IO[String, Int]].monoid.collect0

1621[info] - Monoid[IO[String, Int]].monoid.combine all

1622[info] - Monoid[IO[String, Int]].monoid.combineAllOption

1623[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

1624[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

1625[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

1626[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

1627[info] - Monoid[IO[String, Int]].monoid.is id

1628[info] - Monoid[IO[String, Int]].monoid.left identity

1629[info] - Monoid[IO[String, Int]].monoid.repeat0

1630[info] - Monoid[IO[String, Int]].monoid.repeat1

1631[info] - Monoid[IO[String, Int]].monoid.repeat2

1632[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

1633[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

1634[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

1635[info] - Monoid[IO[String, Int]].monoid.reverseReverses

1636[info] - Monoid[IO[String, Int]].monoid.right identity

1637[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

1638[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1639[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1640[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1641[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1642[info] monix.bio.TaskConversionsSuite

1643[info] - IO.now(value).to[CIO]

1644[info] - IO.eval(thunk).to[CIO]

1645[info] - IO.eval(thunk).executeAsync.to[CIO]

1646[info] - IO.evalTotal(thunk).to[CIO]

1647[info] - IO.evalTotal(thunk).executeAsync.to[CIO]

1648[info] - IO.raiseError(dummy).to[CIO]

1649[info] - IO.raiseError(dummy).executeAsync.to[CIO]

1650[info] - IO.terminate(dummy).to[CIO]

1651[info] - IO.terminate(dummy).executeAsync.to[CIO]

1652[info] - IO.toAsync converts successful tasks

1653[info] - IO.toAsync converts tasks with typed errors

1654[info] - IO.toAsync converts tasks with terminal errors

1655[info] - IO.toConcurrent converts successful tasks

1656[info] - IO.toConcurrent converts tasks with typed errors

1657[info] - IO.toConcurrent converts tasks with terminal errors

1658[info] - IO.fromEffect(task)) <-> task

1659[info] - IO.fromEffect(task.toAsync[Task]) <-> task

1660[info] - IO.fromEffect(task.toAsync[CIO]) <-> task

1661[info] - IO.fromEffect(task.toAsync[F]) <-> task

1662[info] - IO.fromEffect converts `IO`

1663[info] - IO.fromEffect converts valid custom effects

1664[info] - IO.fromEffect doesn't convert invalid custom effects

1665[info] - IO.fromEffect(task.toConcurrent[IO]) preserves cancellability

1666[info] - IO.fromConcurrentEffect(task) <-> task

1667[info] - IO.fromConcurrentEffect(task.toConcurrent[Task]) <-> task

1668[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) <-> task

1669[info] - IO.fromConcurrentEffect(task.toConcurrent[F]) <-> task

1670[info] - IO.fromConcurrentEffect converts `IO`

1671[info] - IO.fromConcurrentEffect converts valid custom effects

1672[info] - IO.fromConcurrentEffect doesn't convert invalid custom effects

1673[info] - IO.fromConcurrentEffect preserves cancellability of an `IO`

1674[info] - IO.fromConcurrentEffect preserves cancellability of a custom effect

1675[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) preserves cancellability

1676[info] - IO.fromConcurrentEffect(task.toConcurrent[CIO]) preserves cancellability

1677[info] - IO.fromReactivePublisher converts `.onNext` callbacks

1678[info] - IO.fromReactivePublisher converts `.onComplete` callbacks

1679[info] - IO.fromReactivePublisher converts `.onError` callbacks

1680[info] - IO.fromReactivePublisher protects against user errors

1681[info] - IO.fromReactivePublisher is cancelable

1682[info] - IO.fromReactivePublisher <-> Task

1683[info] monix.bio.TaskConnectionRefSuite

1684[info] - assign and cancel a Cancelable

1685[info] - assign and cancel a CancelableF

1686[info] - assign and cancel a CancelToken[Task]

1687[info] - cancel a Cancelable on single assignment

1688[info] - cancel a CancelableF on single assignment

1689[info] - cancel a Task on single assignment

1690[info] monix.bio.TaskBracketSuite

1691[info] - equivalence with onErrorHandleWith

1692[info] - equivalence with flatMap + redeemWith

1693[info] - equivalence with flatMap + redeemCauseWith

1694[info] - use is protected against user error

1695[info] - release is evaluated on success

1696[info] - release is evaluated on error

1697[info] - release is evaluated on terminal error

1698[info] - release is evaluated on cancel

1699[info] - if both use and release throw, report release error, signal use error

1700[info] - bracket works with auto-cancelable run-loops

1701[info] - bracket is stack safe (1)

1702[info] - bracket is stack safe (2)

1703[info] - bracket is stack safe (3)

1704[info] - bracket is stack safe (4)

1705[info] - use is not evaluated on cancel

1706[info] - cancel should wait for already started finalizers on success

1707[info] - cancel should wait for already started finalizers on failure

1708[info] - cancel should wait for already started use finalizers

1709[info] - second cancel should wait for use finalizers

1710[info] - second cancel during acquire should wait for it and finalizers to complete

1711[info] - second cancel during acquire should wait for it and finalizers to complete (non-terminating)

1712[info] - Multiple cancel should not hang

1713[info] - bracket can be canceled while failing to acquire

1714[info] - bracket can be canceled while terminating

1715[info] monix.bio.TaskLikeConversionsJava8Suite

1716[info] - IO.from converts successful CompletableFuture

1717[info] - IO.from converts failed CompletableFuture

1718[info] - IO.from preserves cancellability of CompletableFuture

1719[info] monix.bio.TaskLikeConversionsSuite

1720[info] - IO.from(task.to[IO]) <-> task

1721[info] - IO.from converts successful Future

1722[info] - IO.from converts failed Future

1723[info] - IO.from converts successful sync IO

1724[info] - IO.from converts successful async IO

1725[info] - IO.from converts failed sync CIO

1726[info] - IO.from converts failed async IO

1727[info] - IO.from preserves cancellability of an IO

1728[info] - IO.from converts successful Eval

1729[info] - IO.from converts failed Eval

1730[info] - IO.from preserves Eval laziness

1731[info] - IO.from converts successful SyncIO

1732[info] - IO.from converts failed SyncIO

1733[info] - IO.from converts successful Try

1734[info] - IO.from converts failed Try

1735[info] - IO.from converts right Either

1736[info] - IO.from converts left Either

1737[info] - IO.from converts successful custom Effect

1738[info] - IO.from converts failed custom Effect

1739[info] - IO.from converts successful custom ConcurrentEffect

1740[info] - IO.from converts failed custom ConcurrentEffect

1741[info] - IO.from converts Function0

1742[info] - IO.from converts CancelablePromise

1743[info] monix.bio.TaskCancellationSuite

1744[info] - cancellation works for async actions

1745[info] - cancellation works for autoCancelableRunLoops

1746[info] - task.start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> UIO.never

1747[info] - uncancelable works for async actions

1748[info] - uncancelable works for autoCancelableRunLoops

1749[info] - uncancelable is stack safe in flatMap loop, take 1

1750[info] - uncancelable is stack safe in flatMap loop, take 2

1751[info] - fa.onCancelRaiseError <-> fa

1752[info] - fa.onCancelRaiseError(e).start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> raiseError(e)

1753[info] - cancelBoundary happy path

1754[info] - cancelBoundary execution is immediate

1755[info] - cancelBoundary is stack safe

1756[info] - cancelBoundary cancels

1757[info] - onCancelRaiseError resets cancellation flag

1758[info] - errors raised after cancel get reported

1759[info] - terminal errors raised after cancel get reported

1760[info] - onCancelRaiseError is stack safe in flatMap loop, take 1

1761[info] - onCancelRaiseError is stack safe in flatMap loop, take 2

1762[info] - local.write.uncancelable works

1763[info] - local.write.onCancelRaiseError works

1764[info] monix.bio.TaskDelaySuite

1765[info] - IO#delayExecution should work

1766[info] - IO#delayExecution is stack safe, test 1

1767[info] - IO#delayExecution is stack safe, test 2

1768[info] - IO#delayExecution is cancelable

1769[info] - IO#delayResult should work

1770[info] - IO#delayResult is stack safe, test 1

1771[info] - IO#delayResult is stack safe, test 2

1772[info] - IO#delayResult is cancelable

1773[info] - IO#delayResult should not delay in case of error

1774[info] - IO#delayResult should not delay in case of terminal error

1775[info] monix.bio.TaskClockTimerAndContextShiftSuite

1776[info] - IO.clock is implicit

1777[info] - IO.clock.monotonic

1778[info] - IO.clock.realTime

1779[info] - IO.clock(s2).monotonic

1780[info] - IO.clock(s).realTime

1781[info] - IO.timer is implicit

1782[info] - IO.timer

1783[info] - IO.timer(s)

1784[info] - IO.timer(s).clock

1785[info] - IO.contextShift is implicit

1786[info] - IO.contextShift.shift

1787[info] - IO.contextShift.evalOn(s2)

1788[info] - IO.contextShift.evalOn(s2) failure

1789[info] - IO.contextShift.evalOn(s2) fatal failure

1790[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries

1791[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction

1792[info] - IO.contextShift(s).shift

1793[info] - IO.contextShift(s).evalOn(s2)

1794[info] - IO.contextShift(s).evalOn(s2) failure

1795[info] - IO.contextShift(s).evalOn(s2) fatal failure

1796[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries

1797[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction

1798[info] monix.bio.TaskMemoizeSuite

1799[info] - IO.memoize should work asynchronously for first subscriber

1800[info] - IO.memoize should work synchronously for next subscribers

1801[info] - IO.memoize should be stack safe

1802[info] - IO.flatMap.memoize should be stack safe, test 1

1803[info] - IO.flatMap.memoize should be stack safe, test 2

1804[info] - IO.raiseError(error).memoize should work

1805[info] - IO.terminate(error).memoize should work

1806[info] - IO.memoize.materialize

1807[info] - IO.apply(error).memoize.materialize

1808[info] - IO.eval.memoize should work for first subscriber

1809[info] - IO.eval.memoize should work synchronously for next subscribers

1810[info] - IO.eval(error).memoize should work

1811[info] - IO.eval.memoize

1812[info] - IO.eval.memoize should be stack safe

1813[info] - IO.eval.flatMap.memoize should be stack safe

1814[info] - IO.defer(evalAlways).memoize

1815[info] - IO.evalOnce.memoize should work for first subscriber

1816[info] - IO.evalOnce.memoize should work synchronously for next subscribers

1817[info] - IO.evalOnce(error).memoize should work

1818[info] - IO.evalOnce.memoize should be stack safe

1819[info] - IO.evalOnce.flatMap.memoize should be stack safe

1820[info] - IO.now.memoize should work synchronously for first subscriber

1821[info] - IO.now.memoize should work synchronously for next subscribers

1822[info] - IO.error.memoize should work

1823[info] - IO.now.memoize should be stack safe

1824[info] - IO.now.flatMap.memoize should be stack safe

1825[info] - IO.defer.memoize should be stack safe

1826[info] - IO.memoize effects, sequential

1827[info] - IO.memoize effects, parallel

1828[info] - IO.suspend.memoize effects

1829[info] - IO.suspend.flatMap.memoize effects

1830[info] - IO.memoize should make subsequent subscribers wait for the result, as future

1831[info] - IO.memoize should make subsequent subscribers wait for the result, as callback

1832[info] - Task.memoize should be synchronous for subsequent subscribers, as callback

1833[info] - IO.memoize should not be cancelable (future)

1834[info] - IO.memoize should be cancelable (callback, #1)

1835[info] - IO.memoize should be cancelable (callback, #2)

1836[info] - IO.memoize should be re-executable after cancel

1837[info] - IO.memoize should not be uninterruptible

1838[info] - IO.memoize serves error after async boundary

1839[info] - TaskRunLoop.startLightWithBiCallback for success

1840[info] - TaskRunLoop.startLightWithBiCallback for failure

1841[info] - IO.evalOnce eq IO.evalOnce.memoize

1842[info] - IO.eval.memoize eq IO.eval.memoize.memoize

1843[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoize

1844[info] - IO.now.memoize eq IO.now

1845[info] - IO.raiseError.memoize eq IO.raiseError

1846[info] - IO.terminate.memoize eq IO.raiseError

1847[info] - IO.eval.memoizeOnSuccess.memoize !== IO.eval.memoizeOnSuccess

1848[info] monix.bio.TaskExecuteOnSuite

1849[info] - executeOn(forceAsync = false)

1850[info] - executeOn(forceAsync = true)

1851[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1

1852[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2

1853[info] - local.write.executeOn(forceAsync = false) works

1854[info] - local.write.executeOn(forceAsync = true) works

1855[info] monix.bio.TaskParTraverseUnorderedSuite

1856[info] - IO.parTraverseUnordered should execute in parallel

1857[info] - IO.parTraverseUnordered should onError if one of the tasks terminates in error

1858[info] - IO.parTraverseUnordered should be canceled

1859[info] - IO.parTraverseUnordered should run over an iterable

1860[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks

1861[info] - IO.parTraverseUnordered should be stack safe on success

1862[info] - IO.parTraverseUnordered should log errors if multiple errors happen

1863[info] - IO.parTraverseUnordered runAsync multiple times

1865[info] monix.bio.TaskGuaranteeSuite

1866[info] - finalizer is evaluated on success

1867[info] - finalizer is evaluated on error

1868[info] - finalizer is evaluated on terminal error

1869[info] - if finalizer throws, report finalizer error and signal use error

1870[info] - finalizer is evaluated on cancelation (1)

1871[info] - finalizer is evaluated on cancellation (2)

1872[info] - stack-safety (1)

1873[info] - stack-safety (2)

1874[info] - stack-safety (3)

1875[info] monix.bio.TaskExecuteWithModelSuite

1876[info] - executeWithModel works

1877[info] - local.write.executeWithModel(AlwaysAsyncExecution) works

1878[info] - local.write.executeWithModel(SynchronousExecution) works

1879[info] - executeWithModel is stack safe in flatMap loops

1880[info] monix.bio.TaskVoidSuite

1881[info] - IO.void should work

1882[info] monix.bio.IOLikeDoctest

1883[info] - IOLike.scala:29: IOLike

1884[info] monix.bio.TaskSuspendSuite

1885[info] - IO.suspend should suspend evaluation

1886[info] - IO.suspend should protect against user code errors

1887[info] - IO.suspendTotal should protect against unexpected errors

1888[info] monix.bio.TaskExecutionModelSuite

1889[info] - IO.now.executeWithModel(AlwaysAsyncExecution) should work

1890[info] - IO.now.runAsync (CancelableFuture) should not be async with AlwaysAsyncExecution

1891[info] - IO.eval.executeWithModel(AlwaysAsyncExecution) should work

1892[info] - IO.eval should be async with AlwaysAsyncExecution

1893[info] - IO.now.flatMap loops should work with AlwaysAsyncExecution

1894[info] - IO.eval.flatMap loops should work with AlwaysAsyncExecution

1895[info] - IO.flatMap loops should work with AlwaysAsyncExecution

1896[info] monix.bio.TaskFlipSuite

1897[info] - flip successfully swaps the error and value parameters

1898[info] - flipWith should successfully apply the provided function to the swapped error value

1899[info] - flip should not alter original successful value

1900[info] - flipWith should not alter original successful value

1901[info] - F.flip.map(f) <-> F.mapError(f).flip

1902[info] - F.flipWith(f) <-> F.mapError(f)

1903[info] monix.bio.TaskToStringSuite

1904[info] - IO.Now

1905[info] - IO.Error

1906[info] - IO.Termination

1907[info] - IO.Eval

1908[info] - IO.EvalTotal

1909[info] - IO.Async

1910[info] - IO.FlatMap

1911[info] - IO.Suspend

1912[info] - IO.SuspendTotal

1913[info] - IO.Map

1914[info] monix.bio.TaskCreateSuite

1915[info] - can use Unit as return type

1916[info] - can use Cancelable.empty as return type

1917[info] - returning Unit yields non-cancelable tasks

1918[info] - can use Cancelable as return type

1919[info] - returning Cancelable yields a cancelable task

1920[info] - can use CIO[Unit] as return type

1921[info] - returning CIO[Unit] yields a cancelable task

1922[info] - can use IO[E, Unit] as return type

1923[info] - returning IO[E, Unit] yields a cancelable task

1924[info] - throwing error when returning Unit

1925[info] - throwing error when returning Cancelable

1926[info] monix.bio.TaskCallbackSafetyJVMSuite

1927[info] - IO.async has a safe callback

1928[info] - IO.async0 has a safe callback

1929[info] - IO.asyncF has a safe callback

1930[info] - IO.cancelable has a safe callback

1931[info] - IO.cancelable0 has a safe callback

1932[info] monix.bio.TaskMiscSuite

1933[info] - IO.attempt should succeed

1934[info] - IO.raiseError.attempt should expose error

1935[info] - IO.mapError should map error

1936[info] - IO.terminate.attempt should not expose error

1937[info] - IO.tapError should not alter original successful value

1938[info] - IO.tapError should not alter original error value

1939[info] - IO.tapError should not alter original terminal error

1940[info] - IO.failed should expose error

1941[info] - IO.failed should fail for successful values

1942[info] - IO.map protects against user code

1943[info] - IO.forever

1944[info] - IO.restartUntil should keep retrying IO until predicate succeeds

1945[info] - IO.toReactivePublisher should convert tasks with no errors

1946[info] - IO.toReactivePublisher should convert tasks with typed errors

1947[info] - IO.toReactivePublisher should convert tasks with terminal errors

1948[info] - IO.toReactivePublisher should be cancelable

1949[info] - IO.toReactivePublisher should throw errors on invalid requests

1950[info] - IO.pure is an alias of now

1951[info] - IO.now.runAsync with Try-based callback

1952[info] - Task.error.runAsync with Try-based callback

1953[info] - Task.terminate.runAsync with Try-based callback

1954[info] - task.executeAsync.runAsync with Try-based callback for success

1955[info] - task.executeAsync.runAsync with Try-based callback for error

1956[info] - task.executeAsync.runAsync with Try-based callback for terminal error

1957[info] - task.executeWithOptions protects against user error

1958[info] monix.bio.IOStartAndForgetSuite

1959[info] - IO#startAndForget triggers execution in background thread

1960[info] - IO#startAndForget does not affect execution of main thread with raised errors

1961[info] - IO#startAndForget triggers fatal errors in background thread

1962[info] - IO#startAndForget is stack safe

1963[info] monix.bio.IOMapNSuite

1964[info] - IO#map2 should yield value successfully

1965[info] - IO#map2 should propagate error when one argument failed

1966[info] - IO#map2 should protect against user code

1967[info] - IO#map2 should run effects in strict sequence

1968[info] - IO#map3 should yield value successfully

1969[info] - IO#map3 should propagate error when one argument failed

1970[info] - IO#map3 should protect against user code

1971[info] - IO#map3 should run effects in strict sequence

1972[info] - IO#map4 should yield value successfully

1973[info] - IO#map4 should propagate error when one argument failed

1974[info] - IO#map4 should protect against user code

1975[info] - IO#map4 should run effects in strict sequence

1976[info] - IO#map5 should yield value successfully

1977[info] - IO#map5 should propagate error when one argument failed

1978[info] - IO#map5 should protect against user code

1979[info] - IO#map5 should run effects in strict sequence

1980[info] - IO#map6 should yield value successfully

1981[info] - IO#map6 should propagate error when one argument failed

1982[info] - IO#map6 should protect against user code

1983[info] - IO#map6 should run effects in strict sequence

1984[info] monix.bio.TaskEvalOnceSuite

1985[info] - IO.evalOnce should protect against user code errors

1986[info] - IO.evalOnce.flatMap should be equivalent with Task.evalOnce

1987[info] - IO.evalOnce.flatMap should protect against user code

1988[info] - IO.evalOnce.map should work

1989[info] - IO.evalOnce.flatMap should be tail recursive

1990[info] - IO.EvalOnce.runAsync override

1991[info] - IO.evalOnce.materialize should work for success

1992[info] - IO.evalOnce.materialize should work for failure

1993[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite

1994[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1995[info] - CoflatMap[Task].coflatMap.coflatMap identity

1996[info] - CoflatMap[Task].coflatMap.coflatten coherence

1997[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1998[info] - CoflatMap[Task].coflatMap.covariant composition

1999[info] - CoflatMap[Task].coflatMap.covariant identity

2000[info] - CoflatMap[Task].coflatMap.invariant composition

2001[info] - CoflatMap[Task].coflatMap.invariant identity

2002[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2003[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2004[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2005[info] - Concurrent[Task].concurrent.ap consistent with product + map

2006[info] - Concurrent[Task].concurrent.applicative homomorphism

2007[info] - Concurrent[Task].concurrent.applicative identity

2008[info] - Concurrent[Task].concurrent.applicative interchange

2009[info] - Concurrent[Task].concurrent.applicative map

2010[info] - Concurrent[Task].concurrent.applicative unit

2011[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2012[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2013[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2014[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2015[info] - Concurrent[Task].concurrent.applicativeError handle

2016[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2017[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2018[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2019[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2020[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2021[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2022[info] - Concurrent[Task].concurrent.applicativeError handleWith

2023[info] - Concurrent[Task].concurrent.applicativeError onError pure

2024[info] - Concurrent[Task].concurrent.applicativeError onError raise

2025[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2026[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2027[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2028[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2029[info] - Concurrent[Task].concurrent.apply composition

2030[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2031[info] - Concurrent[Task].concurrent.async cancelable coherence

2032[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2033[info] - Concurrent[Task].concurrent.async left is raiseError

2034[info] - Concurrent[Task].concurrent.async right is pure

2035[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2036[info] - Concurrent[Task].concurrent.bind suspends evaluation

2037[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2038[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2039[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2040[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2041[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2042[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2043[info] - Concurrent[Task].concurrent.covariant composition

2044[info] - Concurrent[Task].concurrent.covariant identity

2045[info] - Concurrent[Task].concurrent.delay constant is pure

2046[info] - Concurrent[Task].concurrent.flatMap associativity

2047[info] - Concurrent[Task].concurrent.flatMap consistent apply

2048[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2049[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2050[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2051[info] - Concurrent[Task].concurrent.invariant composition

2052[info] - Concurrent[Task].concurrent.invariant identity

2053[info] - Concurrent[Task].concurrent.join is idempotent

2054[info] - Concurrent[Task].concurrent.map flatMap coherence

2055[info] - Concurrent[Task].concurrent.map suspends evaluation

2056[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2057[info] - Concurrent[Task].concurrent.map2/product-map consistency

2058[info] - Concurrent[Task].concurrent.monad left identity

2059[info] - Concurrent[Task].concurrent.monad right identity

2060[info] - Concurrent[Task].concurrent.monadError ensure consistency

2061[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2062[info] - Concurrent[Task].concurrent.monadError left zero

2063[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2064[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2065[info] - Concurrent[Task].concurrent.monoidal left identity

2066[info] - Concurrent[Task].concurrent.monoidal right identity

2067[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2068[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2069[info] - Concurrent[Task].concurrent.productL consistent map2

2070[info] - Concurrent[Task].concurrent.productR consistent map2

2071[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2072[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2073[info] - Concurrent[Task].concurrent.race cancels both

2074[info] - Concurrent[Task].concurrent.race cancels loser

2075[info] - Concurrent[Task].concurrent.race mirrors left winner

2076[info] - Concurrent[Task].concurrent.race mirrors right winner

2077[info] - Concurrent[Task].concurrent.racePair can join left

2078[info] - Concurrent[Task].concurrent.racePair can join right

2079[info] - Concurrent[Task].concurrent.racePair cancels both

2080[info] - Concurrent[Task].concurrent.racePair cancels loser

2081[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2082[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2083[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2084[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2085[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2086[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2087[info] - Concurrent[Task].concurrent.semigroupal associativity

2088[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2089[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2090[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2091[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2092[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2093[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2094[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2095[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2096[info] - Concurrent[Task].concurrent.start then join is identity

2097[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2098[info] - Concurrent[Task].concurrent.suspend constant is pure join

2099[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2100[info] - Concurrent[Task].concurrent.tailRecM stack safety

2101[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2102[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2103[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2104[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2105[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2106[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2107[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2108[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2109[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2110[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2111[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2112[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2113[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2114[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2115[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2116[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2117[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2118[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2119[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2120[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2121[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2122[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2123[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2124[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2125[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2126[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2127[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2128[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2129[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2130[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2131[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2132[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2133[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2134[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2135[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2136[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2137[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2138[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2139[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2140[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2141[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2142[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2143[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2144[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2145[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2146[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2147[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2148[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2149[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2150[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2151[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2152[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2153[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2154[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2155[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2156[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2157[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2158[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2159[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2160[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2161[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2162[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2163[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2164[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2165[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2166[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2167[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2168[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2169[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2170[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2171[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2172[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2173[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2174[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2175[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2176[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2177[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2178[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2179[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2180[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2181[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2182[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2183[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2184[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2185[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2186[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2187[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2188[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2189[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2190[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2191[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2192[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2193[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2194[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2195[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2196[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2197[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2198[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2199[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2200[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2201[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2202[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2203[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2204[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2205[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2206[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2207[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2208[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2209[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2210[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2211[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2212[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2213[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2214[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2215[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2216[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2217[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2218[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2219[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2220[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2221[info] - Applicative[Task.Par].applicative.ap consistent with product + map

2222[info] - Applicative[Task.Par].applicative.applicative homomorphism

2223[info] - Applicative[Task.Par].applicative.applicative identity

2224[info] - Applicative[Task.Par].applicative.applicative interchange

2225[info] - Applicative[Task.Par].applicative.applicative map

2226[info] - Applicative[Task.Par].applicative.applicative unit

2227[info] - Applicative[Task.Par].applicative.apply composition

2228[info] - Applicative[Task.Par].applicative.covariant composition

2229[info] - Applicative[Task.Par].applicative.covariant identity

2230[info] - Applicative[Task.Par].applicative.invariant composition

2231[info] - Applicative[Task.Par].applicative.invariant identity

2232[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

2233[info] - Applicative[Task.Par].applicative.map2/product-map consistency

2234[info] - Applicative[Task.Par].applicative.monoidal left identity

2235[info] - Applicative[Task.Par].applicative.monoidal right identity

2236[info] - Applicative[Task.Par].applicative.productL consistent map2

2237[info] - Applicative[Task.Par].applicative.productR consistent map2

2238[info] - Applicative[Task.Par].applicative.semigroupal associativity

2239[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2240[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2241[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2242[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2243[info] - Monoid[IO[Throwable, Int]].monoid.associative

2244[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2245[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2246[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2247[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2248[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2249[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2250[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2251[info] - Monoid[IO[Throwable, Int]].monoid.is id

2252[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2253[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2254[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2255[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2256[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2257[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2258[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2259[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2260[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2261[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2262[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2263[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2264[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2265[info] monix.bio.TaskEvalAlwaysSuite

2266[info] - IO.eval should work synchronously

2267[info] - IO.eval should protect against user code errors

2268[info] - IO.eval is equivalent with IO.evalOnce on first run

2269[info] - IO.eval.flatMap should be equivalent with IO.eval

2270[info] - IO.eval.flatMap should protect against user code

2271[info] - IO.eval.flatMap should be tail recursive

2272[info] - IO.eval should not be cancelable

2273[info] - IO.eval.coeval

2274[info] - IO.eval.flatMap should protect against user code errors

2275[info] - IO.delay is an alias for IO.eval

2276[info] - IO.evalTotal should protect against unexpected errors

2277[info] monix.bio.IOFromFutureEitherSuite

2278[info] - IO.fromFutureEither should return success channel for Right

2279[info] - IO.fromFutureEither should return checked failure channel for Left

2280[info] - IO.fromFutureEither should return unchecked failure channel for a failed Future

2281[info] - IO.fromFutureEither(cancelable) should work for Right synchronous results onSuccess

2282[info] - IO.fromFutureEither(cancelable) should work for Left synchronous results onSuccess

2283[info] - IO.fromFutureEither(cancelable) should work for synchronous results onFailure

2284[info] - IO.fromFutureEither(cancelable) should be short-circuited for Right onSuccess

2285[info] - IO.fromFutureEither(cancelable) should be short-circuited for Left onSuccess

2286[info] - IO.fromFutureEither(cancelable) should be short-circuited onError

2287[info] - IO.fromFutureEither(cancelable) should work onSuccess

2288[info] - IO.fromFutureEither(cancelable) should work onError

2289[info] - IO.fromFutureEither(cancelable) should be cancelable

2290[info] - IO.fromFutureEither should be stack safe

2291[info] monix.bio.TaskMemoizeOnSuccessSuite

2292[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber

2293[info] - IO.memoizeOnSuccess should work synchronously for next subscribers

2294[info] - IO.memoizeOnSuccess should be stack safe

2295[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1

2296[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2

2297[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent

2298[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent

2299[info] - IO.memoizeOnSuccess.materialize

2300[info] - IO.raiseError(error).memoizeOnSuccess.materialize

2301[info] - IO.terminate(error).memoizeOnSuccess.materialize

2302[info] - IO.eval.memoizeOnSuccess should work for first subscriber

2303[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers

2304[info] - IO.eval(error).memoizeOnSuccess should not be idempotent

2305[info] - IO.eval.memoizeOnSuccess

2306[info] - IO.eval.memoizeOnSuccess should be stack safe

2307[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe

2308[info] - IO.defer(evalAlways).memoizeOnSuccess

2309[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber

2310[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers

2311[info] - IO.evalOnce(error).memoizeOnSuccess should work

2312[info] - IO.evalOnce.memoizeOnSuccess should be stack safe

2313[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe

2314[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber

2315[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers

2316[info] - IO.raiseError.memoizeOnSuccess should work

2317[info] - IO.terminate.memoizeOnSuccess should work

2318[info] - IO.now.memoizeOnSuccess should be stack safe

2319[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe

2320[info] - IO.suspend.memoizeOnSuccess should be stack safe

2321[info] - IO.memoizeOnSuccess effects, sequential

2322[info] - IO.memoizeOnSuccess effects, parallel

2323[info] - IO.suspend.memoizeOnSuccess effects

2324[info] - IO.suspend.flatMap.memoizeOnSuccess effects

2325[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future

2326[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback

2327[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback

2328[info] - IO.memoizeOnSuccess should be cancellable (future)

2329[info] - IO.memoizeOnSuccess should be cancellable (callback #1)

2330[info] - IO.memoizeOnSuccess should be cancellable (callback #2)

2331[info] - IO.memoizeOnSuccess should not be cancelable

2332[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners

2333[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess

2334[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess

2335[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess

2336[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess

2337[info] - IO.now.memoizeOnSuccess eq IO.now

2338[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError

2339[info] - IO.terminate.memoizeOnSuccess eq IO.terminate

2340[info] monix.bio.TypeClassLawsForTaskSuite

2341[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2342[info] - CoflatMap[Task].coflatMap.coflatMap identity

2343[info] - CoflatMap[Task].coflatMap.coflatten coherence

2344[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2345[info] - CoflatMap[Task].coflatMap.covariant composition

2346[info] - CoflatMap[Task].coflatMap.covariant identity

2347[info] - CoflatMap[Task].coflatMap.invariant composition

2348[info] - CoflatMap[Task].coflatMap.invariant identity

2349[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2350[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2351[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2352[info] - Concurrent[Task].concurrent.ap consistent with product + map

2353[info] - Concurrent[Task].concurrent.applicative homomorphism

2354[info] - Concurrent[Task].concurrent.applicative identity

2355[info] - Concurrent[Task].concurrent.applicative interchange

2356[info] - Concurrent[Task].concurrent.applicative map

2357[info] - Concurrent[Task].concurrent.applicative unit

2358[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2359[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2360[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2361[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2362[info] - Concurrent[Task].concurrent.applicativeError handle

2363[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2364[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2365[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2366[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2367[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2368[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2369[info] - Concurrent[Task].concurrent.applicativeError handleWith

2370[info] - Concurrent[Task].concurrent.applicativeError onError pure

2371[info] - Concurrent[Task].concurrent.applicativeError onError raise

2372[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2373[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2374[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2375[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2376[info] - Concurrent[Task].concurrent.apply composition

2377[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2378[info] - Concurrent[Task].concurrent.async cancelable coherence

2379[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2380[info] - Concurrent[Task].concurrent.async left is raiseError

2381[info] - Concurrent[Task].concurrent.async right is pure

2382[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2383[info] - Concurrent[Task].concurrent.bind suspends evaluation

2384[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2385[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2386[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2387[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2388[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2389[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2390[info] - Concurrent[Task].concurrent.covariant composition

2391[info] - Concurrent[Task].concurrent.covariant identity

2392[info] - Concurrent[Task].concurrent.delay constant is pure

2393[info] - Concurrent[Task].concurrent.flatMap associativity

2394[info] - Concurrent[Task].concurrent.flatMap consistent apply

2395[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2396[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2397[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2398[info] - Concurrent[Task].concurrent.invariant composition

2399[info] - Concurrent[Task].concurrent.invariant identity

2400[info] - Concurrent[Task].concurrent.join is idempotent

2401[info] - Concurrent[Task].concurrent.map flatMap coherence

2402[info] - Concurrent[Task].concurrent.map suspends evaluation

2403[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2404[info] - Concurrent[Task].concurrent.map2/product-map consistency

2405[info] - Concurrent[Task].concurrent.monad left identity

2406[info] - Concurrent[Task].concurrent.monad right identity

2407[info] - Concurrent[Task].concurrent.monadError ensure consistency

2408[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2409[info] - Concurrent[Task].concurrent.monadError left zero

2410[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2411[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2412[info] - Concurrent[Task].concurrent.monoidal left identity

2413[info] - Concurrent[Task].concurrent.monoidal right identity

2414[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2415[info] - Concurrent[Task].concurrent.never is derived from async

2416[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2417[info] - Concurrent[Task].concurrent.productL consistent map2

2418[info] - Concurrent[Task].concurrent.productR consistent map2

2419[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2420[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2421[info] - Concurrent[Task].concurrent.race cancels both

2422[info] - Concurrent[Task].concurrent.race cancels loser

2423[info] - Concurrent[Task].concurrent.race mirrors left winner

2424[info] - Concurrent[Task].concurrent.race mirrors right winner

2425[info] - Concurrent[Task].concurrent.racePair can join left

2426[info] - Concurrent[Task].concurrent.racePair can join right

2427[info] - Concurrent[Task].concurrent.racePair cancels both

2428[info] - Concurrent[Task].concurrent.racePair cancels loser

2429[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2430[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2431[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2432[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2433[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2434[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2435[info] - Concurrent[Task].concurrent.semigroupal associativity

2436[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2437[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2438[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2439[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2440[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2441[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2442[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2443[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2444[info] - Concurrent[Task].concurrent.start then join is identity

2445[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2446[info] - Concurrent[Task].concurrent.suspend constant is pure join

2447[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2448[info] - Concurrent[Task].concurrent.tailRecM stack safety

2449[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2450[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2451[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2452[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2453[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2454[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2455[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2456[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2457[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2458[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2459[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2460[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2461[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2462[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2463[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2464[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2465[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2466[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2467[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2468[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2469[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2470[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2471[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2472[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2473[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2474[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2475[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2476[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2477[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2478[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2479[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2480[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2481[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2482[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2483[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2484[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2485[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2486[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2487[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2488[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2489[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2490[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2491[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2492[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2493[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2494[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2495[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2496[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2497[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2498[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2499[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2500[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2501[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2502[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2503[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2504[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2505[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2506[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2507[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2508[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2509[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2510[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2511[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2512[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2513[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2514[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2515[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2516[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2517[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2518[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2519[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2520[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2521[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2522[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2523[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2524[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2525[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2526[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2527[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2528[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2529[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2530[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2531[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2532[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2533[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2534[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2535[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2536[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2537[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2538[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2539[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2540[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2541[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2542[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2543[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2544[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2545[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2546[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2547[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2548[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2549[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2550[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2551[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2552[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2553[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2554[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2555[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2556[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2557[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2558[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2559[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2560[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2561[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2562[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2563[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2564[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2565[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2566[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2567[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2568[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2569[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2570[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2571[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2572[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2573[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2574[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2575[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2576[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2577[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2578[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2579[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2580[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2581[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2582[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2583[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2584[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2585[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2586[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2587[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2588[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2589[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2590[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2591[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2592[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2593[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2594[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2595[info] - Monoid[IO[String, Int]].monoid.associative

2596[info] - Monoid[IO[String, Int]].monoid.collect0

2597[info] - Monoid[IO[String, Int]].monoid.combine all

2598[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2599[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2600[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2601[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2602[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2603[info] - Monoid[IO[String, Int]].monoid.is id

2604[info] - Monoid[IO[String, Int]].monoid.left identity

2605[info] - Monoid[IO[String, Int]].monoid.repeat0

2606[info] - Monoid[IO[String, Int]].monoid.repeat1

2607[info] - Monoid[IO[String, Int]].monoid.repeat2

2608[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2609[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2610[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2611[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2612[info] - Monoid[IO[String, Int]].monoid.right identity

2613[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2614[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2615[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2616[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2617[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2618[info] monix.bio.TaskMaterializeSuite

2619[info] - IO.now.materialize

2620[info] - IO.error.materialize

2621[info] - IO.terminate.materialize

2622[info] - IO.evalOnce.materialize should be stack safe

2623[info] - IO.eval.materialize

2624[info] - IO.defer.materialize

2625[info] - IO.defer.flatMap.materialize

2626[info] - IO.flatMap.materialize

2627[info] - IO.evalAsync.materialize

2628[info] - IO.evalAsync.flatMap.materialize

2629[info] - IO.evalAsync(error).flatMap.materialize

2630[info] - IO.now.flatMap(error).materialize

2631[info] - IO.defer(error).materialize

2632[info] - IO.deferTotal(error).materialize

2633[info] - IO.defer(error).flatMap.materialize

2634[info] - IO.now.dematerialize

2635[info] - IO.error.dematerialize

2636[info] - IO.materialize should be stack safe

2637[info] - IO.eval.materialize should work for failure

2638[info] - IO.eval.materialize should be stack safe

2639[info] - IO.now.materialize should work

2640[info] - IO.materialize on failing flatMap

2641[info] - IO.now.materialize should be stack safe

2642[info] - IO.raiseError.dematerialize

2643[info] - IO.terminate.dematerialize

2644[info] monix.bio.tracing.StackTracedContextSuite

2645[info] - push traces

2646[info] - track omitted frames

2647[info] monix.bio.FiberDoctest

2648[info] - Fiber.scala:22: Fiber

2649[info] monix.bio.TaskRejectedExecutionSuite

2651[info] monix.bio.TaskSequenceSuite

2652[info] - IO.sequence should not execute in parallel

2653[info] - IO.sequence should onError if one of the tasks terminates in error

2654[info] - IO.sequence should onTerminate if one of the tasks terminates in error

2655[info] - IO.sequence should be canceled

2656[info] monix.bio.TaskParSequenceNSuite

2657[info] - IO.parSequenceN should execute in parallel bounded by parallelism

2658[info] - IO.parSequenceN should return result in order

2659[info] - IO.parSequenceN should return empty list

2660[info] - IO.parSequenceN should handle single item

2661[info] - IO.parSequenceN should handle parallelism bigger than list

2662[info] - IO.parSequenceN should onError if one of the tasks terminates in error

2663[info] - IO.parSequenceN should onTerminate if one of the tasks terminates in a fatal error

2664[info] - IO.parSequenceN should be canceled

2665[info] - IO.parSequenceN should be stack safe for synchronous tasks

2666[info] - IO.parSequenceN runAsync multiple times

2667[info] - IO.parSequenceN should log errors if multiple errors happen

2668[info] - IO.parSequenceN should log terminal errors if multiple errors happen

2669[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite

2670[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2671[info] - CoflatMap[Task].coflatMap.coflatMap identity

2672[info] - CoflatMap[Task].coflatMap.coflatten coherence

2673[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2674[info] - CoflatMap[Task].coflatMap.covariant composition

2675[info] - CoflatMap[Task].coflatMap.covariant identity

2676[info] - CoflatMap[Task].coflatMap.invariant composition

2677[info] - CoflatMap[Task].coflatMap.invariant identity

2678[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

2679[info] - Concurrent[Task].async.ap consistent with product + map

2680[info] - Concurrent[Task].async.applicative homomorphism

2681[info] - Concurrent[Task].async.applicative identity

2682[info] - Concurrent[Task].async.applicative interchange

2683[info] - Concurrent[Task].async.applicative map

2684[info] - Concurrent[Task].async.applicative unit

2685[info] - Concurrent[Task].async.applicativeError adaptError pure

2686[info] - Concurrent[Task].async.applicativeError adaptError raise

2687[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

2688[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

2689[info] - Concurrent[Task].async.applicativeError handle

2690[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

2691[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

2692[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

2693[info] - Concurrent[Task].async.applicativeError handleError pure

2694[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

2695[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

2696[info] - Concurrent[Task].async.applicativeError handleWith

2697[info] - Concurrent[Task].async.applicativeError onError pure

2698[info] - Concurrent[Task].async.applicativeError onError raise

2699[info] - Concurrent[Task].async.applicativeError pure attempt

2700[info] - Concurrent[Task].async.applicativeError raiseError attempt

2701[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

2702[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

2703[info] - Concurrent[Task].async.apply composition

2704[info] - Concurrent[Task].async.async can be derived from asyncF

2705[info] - Concurrent[Task].async.async left is raiseError

2706[info] - Concurrent[Task].async.async right is pure

2707[info] - Concurrent[Task].async.bind suspends evaluation

2708[info] - Concurrent[Task].async.bracket is derived from bracketCase

2709[info] - Concurrent[Task].async.bracket release is called on Completed or Error

2710[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

2711[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

2712[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2713[info] - Concurrent[Task].async.covariant composition

2714[info] - Concurrent[Task].async.covariant identity

2715[info] - Concurrent[Task].async.delay constant is pure

2716[info] - Concurrent[Task].async.flatMap associativity

2717[info] - Concurrent[Task].async.flatMap consistent apply

2718[info] - Concurrent[Task].async.flatMap from tailRecM consistency

2719[info] - Concurrent[Task].async.guarantee is derived from bracket

2720[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

2721[info] - Concurrent[Task].async.invariant composition

2722[info] - Concurrent[Task].async.invariant identity

2723[info] - Concurrent[Task].async.map flatMap coherence

2724[info] - Concurrent[Task].async.map suspends evaluation

2725[info] - Concurrent[Task].async.map2/map2Eval consistency

2726[info] - Concurrent[Task].async.map2/product-map consistency

2727[info] - Concurrent[Task].async.monad left identity

2728[info] - Concurrent[Task].async.monad right identity

2729[info] - Concurrent[Task].async.monadError ensure consistency

2730[info] - Concurrent[Task].async.monadError ensureOr consistency

2731[info] - Concurrent[Task].async.monadError left zero

2732[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

2733[info] - Concurrent[Task].async.monadError rethrow attempt

2734[info] - Concurrent[Task].async.monoidal left identity

2735[info] - Concurrent[Task].async.monoidal right identity

2736[info] - Concurrent[Task].async.mproduct consistent flatMap

2737[info] - Concurrent[Task].async.never is derived from async

2738[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

2739[info] - Concurrent[Task].async.productL consistent map2

2740[info] - Concurrent[Task].async.productR consistent map2

2741[info] - Concurrent[Task].async.propagate errors through bind (async)

2742[info] - Concurrent[Task].async.propagate errors through bind (suspend)

2743[info] - Concurrent[Task].async.repeated async evaluation not memoized

2744[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

2745[info] - Concurrent[Task].async.repeated sync evaluation not memoized

2746[info] - Concurrent[Task].async.semigroupal associativity

2747[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

2748[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

2749[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

2750[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

2751[info] - Concurrent[Task].async.stack-safe on left-associated binds

2752[info] - Concurrent[Task].async.stack-safe on repeated attempts

2753[info] - Concurrent[Task].async.stack-safe on repeated maps

2754[info] - Concurrent[Task].async.stack-safe on right-associated binds

2755[info] - Concurrent[Task].async.suspend constant is pure join

2756[info] - Concurrent[Task].async.tailRecM consistent flatMap

2757[info] - Concurrent[Task].async.tailRecM stack safety

2758[info] - Concurrent[Task].async.throw in delay is raiseError

2759[info] - Concurrent[Task].async.throw in suspend is raiseError

2760[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

2761[info] - Concurrent[Task].async.unsequenced delay is no-op

2762[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

2763[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

2764[info] - ConcurrentEffect[Task].effect.applicative homomorphism

2765[info] - ConcurrentEffect[Task].effect.applicative identity

2766[info] - ConcurrentEffect[Task].effect.applicative interchange

2767[info] - ConcurrentEffect[Task].effect.applicative map

2768[info] - ConcurrentEffect[Task].effect.applicative unit

2769[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

2770[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

2771[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

2772[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

2773[info] - ConcurrentEffect[Task].effect.applicativeError handle

2774[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

2775[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

2776[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

2777[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

2778[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

2779[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

2780[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

2781[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

2782[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

2783[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

2784[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

2785[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

2786[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

2787[info] - ConcurrentEffect[Task].effect.apply composition

2788[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

2789[info] - ConcurrentEffect[Task].effect.async left is raiseError

2790[info] - ConcurrentEffect[Task].effect.async right is pure

2791[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

2792[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

2793[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

2794[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

2795[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

2796[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2797[info] - ConcurrentEffect[Task].effect.covariant composition

2798[info] - ConcurrentEffect[Task].effect.covariant identity

2799[info] - ConcurrentEffect[Task].effect.delay constant is pure

2800[info] - ConcurrentEffect[Task].effect.flatMap associativity

2801[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

2802[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

2803[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

2804[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

2805[info] - ConcurrentEffect[Task].effect.invariant composition

2806[info] - ConcurrentEffect[Task].effect.invariant identity

2807[info] - ConcurrentEffect[Task].effect.map flatMap coherence

2808[info] - ConcurrentEffect[Task].effect.map suspends evaluation

2809[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

2810[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

2811[info] - ConcurrentEffect[Task].effect.monad left identity

2812[info] - ConcurrentEffect[Task].effect.monad right identity

2813[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

2814[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

2815[info] - ConcurrentEffect[Task].effect.monadError left zero

2816[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

2817[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

2818[info] - ConcurrentEffect[Task].effect.monoidal left identity

2819[info] - ConcurrentEffect[Task].effect.monoidal right identity

2820[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

2821[info] - ConcurrentEffect[Task].effect.never is derived from async

2822[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

2823[info] - ConcurrentEffect[Task].effect.productL consistent map2

2824[info] - ConcurrentEffect[Task].effect.productR consistent map2

2825[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

2826[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

2827[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

2828[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

2829[info] - ConcurrentEffect[Task].effect.repeated callback ignored

2830[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

2831[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

2832[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

2833[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

2834[info] - ConcurrentEffect[Task].effect.semigroupal associativity

2835[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

2836[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

2837[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

2838[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

2839[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

2840[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

2841[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

2842[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

2843[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

2844[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

2845[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

2846[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

2847[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

2848[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

2849[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

2850[info] - ConcurrentEffect[Task].effect.toIO stack safety

2851[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

2852[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

2853[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2854[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2855[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2856[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2857[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2858[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2859[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2860[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2861[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2862[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2863[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2864[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2865[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2866[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2867[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2868[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2869[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2870[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2871[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2872[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

2873[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

2874[info] - Parallel[Task, Task.Par].parallel.parallel round trip

2875[info] - Parallel[Task, Task.Par].parallel.sequential round trip

2876[info] - Monoid[IO[Throwable, Int]].monoid.associative

2877[info] - Monoid[IO[Throwable, Int]].monoid.collect0

2878[info] - Monoid[IO[Throwable, Int]].monoid.combine all

2879[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

2880[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

2881[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

2882[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

2883[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

2884[info] - Monoid[IO[Throwable, Int]].monoid.is id

2885[info] - Monoid[IO[Throwable, Int]].monoid.left identity

2886[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

2887[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

2888[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

2889[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

2890[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

2891[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

2892[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

2893[info] - Monoid[IO[Throwable, Int]].monoid.right identity

2894[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2895[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2896[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2897[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2898[info] monix.bio.TaskRaceSuite

2899[info] - IO.raceMany returns fastest success

2900[info] - IO.raceMany returns fastest typed error

2901[info] - IO.raceMany returns fastest terminal error

2902[info] - IO.raceMany returns success that is faster than typed error

2903[info] - IO.raceMany returns success that is faster than terminal error

2904[info] - IO.raceMany returns typed error that is faster than success

2905[info] - IO.raceMany returns typed error that is faster than fatal error

2906[info] - IO.raceMany returns fatal error that is faster than success

2907[info] - IO.raceMany returns fatal error that is faster than typed error

2908[info] - IO.raceMany should allow cancelling all tasks

2909[info] - IO.raceMany should be stack safe for sync values

2910[info] - IO.raceMany should be stack safe for async values

2911[info] - IO.raceMany has a stack safe cancelable

2912[info] - IO#timeout should timeout

2913[info] - IO#timeout should mirror the source in case of success

2914[info] - IO#timeout should mirror the source in case of error

2915[info] - IO#timeout should mirror the source in case of terminal error

2916[info] - IO#timeout should cancel both the source and the timer

2917[info] - IO#timeout with backup should timeout

2918[info] - IO#timeout with backup should timeout with error

2919[info] - IO#timeout with backup should mirror the source in case of success

2920[info] - IO#timeout with backup should mirror the source in case of error

2921[info] - IO#timeout should cancel both the source and the timer

2922[info] - IO#timeout should cancel the backup

2923[info] - IO#timeout should not return the source after timeout

2924[info] - IO#timeout should cancel the source after timeout

2925[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization

2926[info] - IO#timeoutL should evaluate as specified: lazy, with memoization

2927[info] - IO#timeoutL considers time taken to evaluate the duration task

2928[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed

2929[info] - IO.racePair(a,b) should work if a completes first

2930[info] - IO.racePair(a,b) should cancel both

2931[info] - IO.racePair(A,B) should not cancel B if A completes first

2932[info] - IO.racePair(A,B) should not cancel A if B completes first

2933[info] - IO.racePair(A,B) should end both in error if A completes first in error

2934[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error

2935[info] - IO.racePair(A,B) should end both in error if B completes first in error

2936[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error

2937[info] - IO.racePair(A,B) should work if A completes second in error

2938[info] - IO.racePair(A,B) should work if A completes second in terminal error

2939[info] - IO.racePair(A,B) should work if B completes second in error

2940[info] - IO.racePair should be stack safe, take 1

2941[info] - IO.racePair should be stack safe, take 2

2942[info] - IO.racePair has a stack safe cancelable

2943[info] - IO.race(a, b) should work if a completes first

2944[info] - IO.race(a, b) should work if b completes first

2945[info] - IO.race(a, b) should cancel both

2946[info] - IO.race(a, b) should end both in error if `a` completes first in error

2947[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error

2948[info] - IO.race(a, b) should end both in error if `b` completes first in error

2949[info] - IO.race(a, b) should end both in error if `b` completes first in error

2950[info] - IO.race(a, b) should work if `a` completes in typed error

2951[info] - IO.race(a, b) should work if `a` completes in unexpected error

2952[info] - IO.race(a, b) should work if `b` completes in typed error

2953[info] - IO.race(a, b) should work if `b` completes in unexpected error

2954[info] - IO.race should be stack safe, take 1

2955[info] - IO.race should be stack safe, take 2

2956[info] - Task.race has a stack safe cancelable

2958************************

2959Build summary:

2960[{

2961 "module": "monix-bio",

2962 "compile": {"status": "ok", "tookMs": 19583, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2963 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2964 "test-compile": {"status": "ok", "tookMs": 34496, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2965 "test": {"status": "ok", "tookMs": 30119, "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: 101 s (0:01:41.0), completed Nov 28, 2025, 12:17:14 PM

2973[0JChecking patch project/plugins.sbt...

2974Checking patch project/build.properties...

2975Checking patch build.sbt...

2976Applied patch project/plugins.sbt cleanly.

2977Applied patch project/build.properties cleanly.

2978Applied patch build.sbt cleanly.