Where communities thrive

  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
Repo info
Rob Norris
Remove the import for cats.syntax.apply
If you import cats.implicits, which you should, you don’t need (and in fact cannot use) the fine-grained imports for instances and syntax.
Now my app can compile without that error. Thanks @tpolecat
Rob Norris
Jakub Kozłowski
I'm trying to implement Eq for Cofree using the definition in https://hackage.haskell.org/package/free-4.1/docs/Control-Comonad-Cofree.html - so far one wall I hit is a diverging implicit... since I don't see Cats depending on shapeless, do we have a different mechanism of coping with these than Lazy?
(Eq (f (Cofree f a)), Eq a) => Eq (Cofree f a)
translated to Scala that's implicit def catsFreeEqForCofree[S[_], A : Eq](implicit S: Eq[S[Cofree[S, A]]]): Eq[Cofree[S, A]]
I have a workaround, but it requires Foldable and Applicative for S[_]
instead of Eq - and it's basically eqv x y = x.head == y.tail && (x.tail, y.tail).product.forall { case (a, b) => eqv(a, b) }
any better ideas?
funny thing is, it's divering for S = List but works fine for Option
Jakub Kozłowski
if only this was possible: implicit def catsFreeEqForCofree[S[_], A : Eq](implicit S: Eq[Cofree[S, A]] => Eq[S[Cofree[S, A]]])
with implicit function types, who knows...
Jakub Kozłowski
trait Eq[A]
trait X[A]

implicit val forXOfA: implicit Eq[Int] => Eq[X[Int]] = null
implicitly[implicit Eq[Int] => Eq[X[Int]]]
nope, still doesn't compile (implicit not found)
Alexander Konovalov
you need quantified contexts
Jakub Kozłowski
please enlighten me
basically haskell?
or this
Jakub Kozłowski
looks like it
wonder if there's a mechanism already used in cats
Alexander Konovalov
I doubt it.
considering there is no Forall
Jakub Kozłowski
so with that in mind
implicit def forListOfA[A](implicit A: Eq[A]): Eq[List[A]] = ???
implicitly[implicit Eq[Int] => Eq[List[Int]]]
would it be the first or the second line that needed e.g. forall?
to me it looks like valid scala
it might even work if A: Eq[A] in the first line isn't marked implicit
aaaand the implicit keyword disappears in the second line
but that's just an implicit view then
Rob Norris
@kubukoz you might look at how these are defined in matryoshka
Jakub Kozłowski

so my reasoning for this working in dotty is that:

implicit def forList[A](A: Eq[A]): Eq[List[A]] = ???
implicitly[Eq[Int] => Eq[List[Int]]]

compiles in scala, then

implicit def forList[A]: implicit Eq[A] => Eq[List[A]] = ???
implicitly[implicit Eq[Int] => Eq[List[Int]]]

should also compile

@tpolecat I'll take a look (later), thanks
I was thinking about sth like trait EqK[F[_]] { def eqv[A](x: F[A], y: F[A]): Boolean } before
Jakub Kozłowski
you know what, this could actually work... an EqK[F[_]], Eq[A] => Eq[F[A]] derivation would be trivial
or EqK could just be a type alias: type EqK[F[_]] = Eq ~> λ[α => Eq[F[α]]]
with a derivation of Eq: implicit def eqKToEq[F[_] : EqK, A : Eq]: Eq[F[A]] = implicitly[EqK[F]].apply(Eq[A])
and instead of defining an Eq[List[A]] we'd define EqK[List], and the rest would be done by the conversion
massive incompatibilities though... without breaking the best we could do is probably define EqK as a separate typeclass, and duplicate the instances for Option, List etc. (I guess)
Jakub Kozłowski
still confused why Eq[Cofree[List, Int]] breaks and Eq[Cofree[Option, Int]]doesn't
ah, I know. It would, I was just checking in CofreeSuite where it's defined explicitly :joy:
Jakub Kozłowski
oh, and it looks like we'd need the same for Order and Show...
Mateusz Górski
Hi, I am confused about use case for MVar and Ref. Looking at their interface they both provide methods for get: F[A] and set/put(a: A): F[Unit]. Can't MVar in place of Ref? I understand that MVar can be used as a communication channel ( blocking on get and put ) which is not possible with Ref.
Derek Williams
@goral09 A Ref wont block on get, but an MVar might if no value is available. So an MVar cannot be used in place of a Ref if a value is always expected.
Fabio Labella
@goral09 a very, very important difference is that modify on Ref is atomic
just to give a bit of perspective, Ref and Deferred are coming from fs2, MVar is coming from Monix (and of course from Haskell, although in Haskell you also have STM)