search

arrow-kt / arrow-incubator

Λrrow Incubator is part of Λrrow, a functional companion to Kotlin's Standard Library
http://arrow-kt.io
Other
20 stars 3 forks source link

Error when sync release/0.11.0 with master #82

Closed github-actions[bot] closed 4 years ago

github-actions[bot] commented 4 years ago

Error log

https://github.com/arrow-kt/arrow-incubator/commit/ab0450671148f030105871d5ff55cb173a0afbb8/checks

Conflicts

diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/AccumTTest.kt
index 2902bad,7f83635..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/AccumTTest.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/AccumTTest.kt
@@@ -19,12 -19,24 +19,29 @@@ import arrow.core.extensions.option.alt
  import arrow.core.extensions.option.eqK.eqK
  import arrow.core.extensions.option.monad.monad
  import arrow.core.extensions.tuple2.eq.eq
+ import arrow.core.test.UnitSpec
+ import arrow.core.test.generators.GenK
+ import arrow.core.test.generators.genK
+ import arrow.core.test.generators.throwable
+ import arrow.core.test.generators.tuple2
+ import arrow.core.test.laws.AlternativeLaws
+ import arrow.core.test.laws.MonadErrorLaws
  import arrow.core.toT
  import arrow.fx.IO
 -import arrow.fx.extensions.io.monadIO.monadIO
 +import arrow.fx.extensions.monadIO
  import arrow.fx.fix
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/AccumTTest.kt
 +import arrow.fx.mtl.monadIO
 +import arrow.fx.unsafeRunSync
++=======
+ import arrow.fx.mtl.accumt.monadIO.monadIO
+ import arrow.fx.test.laws.equalUnderTheLaw
+ import arrow.mtl.AccumT
+ import arrow.mtl.AccumTPartialOf
+ import arrow.mtl.StateT
+ import arrow.mtl.StateTPartialOf
+ import arrow.mtl.WriterT
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/AccumTTest.kt
  import arrow.mtl.extensions.accumt.alternative.alternative
  import arrow.mtl.extensions.accumt.functor.functor
  import arrow.mtl.extensions.accumt.monad.monad
diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/EitherTTest.kt
index f24ff24,a6dd6b7..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/EitherTTest.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/EitherTTest.kt
@@@ -18,16 -18,20 +18,31 @@@ import arrow.core.extensions.id.monad.m
  import arrow.core.extensions.id.traverse.traverse
  import arrow.core.extensions.monoid
  import arrow.core.extensions.option.functor.functor
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/EitherTTest.kt
 +import arrow.fx.IO
 +import arrow.fx.IOPartialOf
 +import arrow.fx.extensions.io.applicative.applicative
 +import arrow.fx.extensions.io.concurrent.concurrent
 +import arrow.fx.extensions.io.functor.functor
 +import arrow.fx.extensions.io.monad.monad
 +import arrow.fx.mtl.concurrent
 +import arrow.fx.mtl.timer
++=======
+ import arrow.core.test.UnitSpec
+ import arrow.core.test.generators.genK
+ import arrow.core.test.generators.throwable
+ import arrow.core.test.laws.AlternativeLaws
+ import arrow.core.test.laws.DivisibleLaws
+ import arrow.core.test.laws.MonadErrorLaws
+ import arrow.core.test.laws.TraverseLaws
+ import arrow.fx.ForIO
+ import arrow.fx.IO
+ import arrow.fx.test.eq.throwableEq
+ import arrow.mtl.EitherT
+ import arrow.mtl.EitherTPartialOf
+ import arrow.mtl.ForEitherT
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/EitherTTest.kt
  import arrow.mtl.extensions.eithert.alternative.alternative
- import arrow.mtl.extensions.eithert.applicative.applicative
  import arrow.mtl.extensions.eithert.apply.apply
  import arrow.mtl.extensions.eithert.divisible.divisible
  import arrow.mtl.extensions.eithert.eqK.eqK
@@@ -71,15 -68,15 +79,27 @@@ class EitherTTest : UnitSpec() 
          idEQK
        ),

++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/EitherTTest.kt
 +      ConcurrentLaws.laws<EitherTPartialOf<String, IOPartialOf<Nothing>>>(
 +        EitherT.concurrent(IO.concurrent()),
 +        EitherT.timer(IO.concurrent()),
 +        EitherT.functor(IO.functor()),
 +        EitherT.applicative(IO.applicative()),
 +        EitherT.monad(IO.monad()),
 +        EitherT.genK(IO.genK(), Gen.string()),
 +        ioEQK
 +      ),
++=======
+       // ConcurrentLaws.laws<EitherTPartialOf<String, ForIO>>(
+       //   EitherT.concurrent(IO.concurrent()),
+       //   EitherT.timer(IO.concurrent()),
+       //   EitherT.functor(IO.functor()),
+       //   EitherT.applicative(IO.applicative()),
+       //   EitherT.monad(IO.monad()),
+       //   EitherT.genK(IO.genK(), Gen.string()),
+       //   ioEQK
+       // ),
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/EitherTTest.kt

        TraverseLaws.laws(EitherT.traverse<Int, ForId>(Id.traverse()),
          EitherT.genK(Id.genK(), Gen.int()),
diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/KleisliTest.kt
index 0cbddb7,4d0233c..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/KleisliTest.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/KleisliTest.kt
@@@ -15,25 -15,20 +15,31 @@@ import arrow.core.extensions.id.monad.m
  import arrow.core.extensions.monoid
  import arrow.core.extensions.option.alternative.alternative
  import arrow.core.extensions.option.eqK.eqK
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/KleisliTest.kt
 +import arrow.fx.IO
 +import arrow.fx.IOPartialOf
 +import arrow.fx.extensions.io.applicative.applicative
 +import arrow.fx.extensions.io.concurrent.concurrent
 +import arrow.fx.extensions.io.functor.functor
 +import arrow.fx.extensions.io.monad.monad
 +import arrow.fx.mtl.concurrent
 +import arrow.fx.mtl.timer
++=======
+ import arrow.core.test.UnitSpec
+ import arrow.core.test.generators.GenK
+ import arrow.core.test.generators.genK
+ import arrow.core.test.laws.AlternativeLaws
+ import arrow.core.test.laws.DivisibleLaws
+ import arrow.fx.ForIO
+ import arrow.fx.IO
+ import arrow.mtl.ForKleisli
+ import arrow.mtl.Kleisli
+ import arrow.mtl.KleisliPartialOf
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/KleisliTest.kt
  import arrow.mtl.extensions.kleisli.alternative.alternative
- import arrow.mtl.extensions.kleisli.applicative.applicative
  import arrow.mtl.extensions.kleisli.divisible.divisible
- import arrow.mtl.extensions.kleisli.functor.functor
- import arrow.mtl.extensions.kleisli.monad.monad
- import arrow.test.UnitSpec
- import arrow.test.generators.GenK
- import arrow.test.generators.genK
- import arrow.test.laws.AlternativeLaws
- import arrow.test.laws.ConcurrentLaws
- import arrow.test.laws.DivisibleLaws
+ import arrow.mtl.fix
+ import arrow.mtl.test.eq.eqK
  import arrow.typeclasses.Eq
  import arrow.typeclasses.EqK
  import io.kotlintest.properties.Gen
@@@ -72,15 -67,15 +78,27 @@@ class KleisliTest : UnitSpec() 
          genK<Int, ForOption>(Option.genK()),
          optionEQK
        ),
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/KleisliTest.kt
 +      ConcurrentLaws.laws<KleisliPartialOf<Int, IOPartialOf<Nothing>>>(
 +        Kleisli.concurrent(IO.concurrent()),
 +        Kleisli.timer(IO.concurrent()),
 +        Kleisli.functor(IO.functor()),
 +        Kleisli.applicative(IO.applicative()),
 +        Kleisli.monad(IO.monad()),
 +        genK(IO.genK()),
 +        ioEQK
 +      ),
++=======
+       // ConcurrentLaws.laws<KleisliPartialOf<Int, ForIO>>(
+       //   Kleisli.concurrent(IO.concurrent()),
+       //   Kleisli.timer(IO.concurrent()),
+       //   Kleisli.functor(IO.functor()),
+       //   Kleisli.applicative(IO.applicative()),
+       //   Kleisli.monad(IO.monad()),
+       //   genK(IO.genK()),
+       //   ioEQK
+       // ),
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/KleisliTest.kt
        DivisibleLaws.laws(
          Kleisli.divisible<Int, ConstPartialOf<Int>>(Const.divisible(Int.monoid())),
          genK<Int, ConstPartialOf<Int>>(Const.genK(Gen.int())),
diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/OptionTTest.kt
index 324b942,f6647d2..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/OptionTTest.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/OptionTTest.kt
@@@ -19,14 -19,20 +19,30 @@@ import arrow.core.extensions.nonemptyli
  import arrow.core.extensions.option.eqK.eqK
  import arrow.core.extensions.option.monad.monad
  import arrow.core.extensions.option.traverseFilter.traverseFilter
+ import arrow.core.test.UnitSpec
+ import arrow.core.test.generators.GenK
+ import arrow.core.test.generators.genK
+ import arrow.core.test.generators.option
+ import arrow.core.test.laws.DivisibleLaws
+ import arrow.core.test.laws.FunctorFilterLaws
+ import arrow.core.test.laws.MonoidKLaws
+ import arrow.core.test.laws.SemigroupKLaws
+ import arrow.core.test.laws.TraverseFilterLaws
  import arrow.fx.IO
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/OptionTTest.kt
 +import arrow.fx.IOPartialOf
 +import arrow.fx.extensions.io.applicative.applicative
 +import arrow.fx.extensions.io.concurrent.concurrent
 +import arrow.fx.extensions.io.functor.functor
 +import arrow.fx.extensions.io.monad.monad
 +import arrow.fx.mtl.concurrent
 +import arrow.fx.mtl.timer
++=======
+ import arrow.mtl.EitherT
+ import arrow.mtl.ForOptionT
+ import arrow.mtl.OptionT
+ import arrow.mtl.OptionTPartialOf
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/OptionTTest.kt
  import arrow.mtl.extensions.ComposedFunctorFilter
  import arrow.mtl.extensions.nested
  import arrow.mtl.extensions.optiont.applicative.applicative
@@@ -68,15 -63,15 +73,27 @@@ class OptionTTest : UnitSpec() 
      val nestedEQK = OptionT.eqK(Id.eqK()).nested(OptionT.eqK(NonEmptyList.eqK()))

      testLaws(
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/OptionTTest.kt
 +      ConcurrentLaws.laws<OptionTPartialOf<IOPartialOf<Nothing>>>(
 +        OptionT.concurrent(IO.concurrent()),
 +        OptionT.timer(IO.concurrent()),
 +        OptionT.functor(IO.functor()),
 +        OptionT.applicative(IO.monad()),
 +        OptionT.monad(IO.monad()),
 +        OptionT.genK(IO.genK()),
 +        ioEQK
 +      ),
++=======
+       // ConcurrentLaws.laws(
+       //   OptionT.concurrent(IO.concurrent()),
+       //   OptionT.timer(IO.concurrent()),
+       //   OptionT.functor(IO.functor()),
+       //   OptionT.applicative(IO.monad()),
+       //   OptionT.monad(IO.monad()),
+       //   OptionT.genK(IO.genK()),
+       //   ioEQK
+       // ),
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/OptionTTest.kt

        SemigroupKLaws.laws(
          OptionT.semigroupK(Option.monad()),
diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/StateTTests.kt
index df98736,b9a006b..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/StateTTests.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/StateTTests.kt
@@@ -11,8 -11,14 +11,18 @@@ import arrow.core.extensions.option.mon
  import arrow.core.extensions.option.monadCombine.monadCombine
  import arrow.core.extensions.option.semigroupK.semigroupK
  import arrow.core.extensions.tuple2.eq.eq
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/StateTTests.kt
++=======
+ import arrow.core.test.UnitSpec
+ import arrow.core.test.generators.GenK
+ import arrow.core.test.generators.genK
+ import arrow.core.test.generators.tuple2
+ import arrow.core.test.laws.MonadCombineLaws
+ import arrow.core.test.laws.SemigroupKLaws
+ import arrow.fx.ForIO
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/StateTTests.kt
  import arrow.fx.IO
 +import arrow.fx.IOPartialOf
  import arrow.fx.extensions.io.async.async
  import arrow.fx.extensions.io.functor.functor
  import arrow.fx.extensions.io.monad.monad
diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/WriterTTest.kt
index 2408d3d,edc82be..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/WriterTTest.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/WriterTTest.kt
@@@ -22,14 -22,18 +22,29 @@@ import arrow.core.extensions.option.fun
  import arrow.core.extensions.option.monad.monad
  import arrow.core.extensions.option.monadFilter.monadFilter
  import arrow.core.k
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/WriterTTest.kt
 +import arrow.fx.IO
 +import arrow.fx.IOPartialOf
 +import arrow.fx.extensions.io.applicative.applicative
 +import arrow.fx.extensions.io.concurrent.concurrent
 +import arrow.fx.extensions.io.functor.functor
 +import arrow.fx.extensions.io.monad.monad
 +import arrow.fx.mtl.concurrent
 +import arrow.fx.mtl.timer
++=======
+ import arrow.core.test.UnitSpec
+ import arrow.core.test.generators.GenK
+ import arrow.core.test.generators.genK
+ import arrow.core.test.generators.tuple2
+ import arrow.core.test.laws.AlternativeLaws
+ import arrow.core.test.laws.DivisibleLaws
+ import arrow.core.test.laws.MonadFilterLaws
+ import arrow.core.test.laws.MonoidKLaws
+ import arrow.fx.ForIO
+ import arrow.fx.IO
+ import arrow.mtl.WriterT
+ import arrow.mtl.WriterTPartialOf
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/WriterTTest.kt
  import arrow.mtl.extensions.WriterTEqK
  import arrow.mtl.extensions.writert.alternative.alternative
  import arrow.mtl.extensions.writert.applicative.applicative
@@@ -84,15 -78,15 +89,27 @@@ class WriterTTest : UnitSpec() 
          WriterT.genK(Const.genK(Gen.int()), Gen.list(Gen.int()).map { it.k() }),
          constEQK()
        ),
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/WriterTTest.kt
 +      ConcurrentLaws.laws<WriterTPartialOf<ListK<Int>, IOPartialOf<Nothing>>>(
 +        WriterT.concurrent(IO.concurrent(), ListK.monoid()),
 +        WriterT.timer(IO.concurrent(), ListK.monoid()),
 +        WriterT.functor(IO.functor()),
 +        WriterT.applicative(IO.applicative(), ListK.monoid()),
 +        WriterT.monad(IO.monad(), ListK.monoid()),
 +        WriterT.genK(IO.genK(), Gen.list(Gen.int()).map { it.k() }),
 +        ioEQK()
 +      ),
++=======
+       // ConcurrentLaws.laws(
+       //   WriterT.concurrent(IO.concurrent(), ListK.monoid<Int>()),
+       //   WriterT.timer(IO.concurrent(), ListK.monoid<Int>()),
+       //   WriterT.functor<ListK<Int>, ForIO>(IO.functor()),
+       //   WriterT.applicative(IO.applicative(), ListK.monoid<Int>()),
+       //   WriterT.monad(IO.monad(), ListK.monoid<Int>()),
+       //   WriterT.genK(IO.genK(), Gen.list(Gen.int()).map { it.k() }),
+       //   ioEQK()
+       // ),
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/WriterTTest.kt
        MonoidKLaws.laws(
          WriterT.monoidK<ListK<Int>, ForListK>(ListK.monoidK()),
          WriterT.genK(ListK.genK(), Gen.list(Gen.int()).map { it.k() }),
diff --cc arrow-mtl-data/src/test/kotlin/arrow/mtl/test/eq/EqK.kt
index ac184c7,c137503..0000000
--- a/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/eq/EqK.kt
+++ b/arrow-mtl-data/src/test/kotlin/arrow/mtl/test/eq/EqK.kt
@@@ -10,26 -10,14 +10,27 @@@ import arrow.fx.IOPartialO
  import arrow.fx.fix
  import arrow.fx.typeclasses.Duration
  import arrow.fx.typeclasses.seconds
- import arrow.test.generators.GenK
  import arrow.typeclasses.Eq
  import arrow.typeclasses.EqK
- import io.kotlintest.properties.Gen

 -fun IO.Companion.eqK(timeout: Duration = 60.seconds) = object : EqK<ForIO> {
 -  override fun <A> Kind<ForIO, A>.eqK(other: Kind<ForIO, A>, EQ: Eq<A>): Boolean =
 -    Either.eq(Eq.any(), EQ).run {
 -      IO.applicative().mapN(fix().attempt(), other.fix().attempt()) { (a, b) -> a.eqv(b) }
 -        .waitFor(timeout)
 -        .unsafeRunSync()
 +fun IO.Companion.eqK(timeout: Duration = 60.seconds) = object : EqK<IOPartialOf<Nothing>> {
 +  override fun <A> Kind<IOPartialOf<Nothing>, A>.eqK(other: Kind<IOPartialOf<Nothing>, A>, EQ: Eq<A>): Boolean =
 +    (this.fix() to other.fix()).let {
 +      val ls = it.first.attempt().unsafeRunTimed(timeout)
 +      val rs = it.second.attempt().unsafeRunTimed(timeout)
 +
 +      Option.eq(Either.eq(Eq.any(), Either.eq(Eq.any(), EQ))).run {
 +        ls.eqv(rs)
 +      }
 +    }
 +}
++<<<<<<< HEAD:arrow-mtl-data/src/test/kotlin/arrow/mtl/ioExtensions.kt
 +
 +fun IO.Companion.genK() = object : GenK<IOPartialOf<Nothing>> {
 +  override fun <A> genK(gen: Gen<A>): Gen<Kind<IOPartialOf<Nothing>, A>> =
 +    gen.map {
 +      IO.just(it)
      }
  }
++=======
++>>>>>>> origin/master:arrow-mtl-data/src/test/kotlin/arrow/mtl/test/eq/EqK.kt
* Unmerged path arrow-aql/src/test/kotlin/arrow/aql/tests/IOExample.kt
* Unmerged path arrow-incubator-test/src/main/kotlin/arrow/test/laws/ApplicativeErrorLaws.kt
* Unmerged path arrow-incubator-test/src/main/kotlin/arrow/test/laws/TraverseLaws.kt
rachelcarmena commented 4 years ago

Duplicated #95