Welcome! Got a question? Do you have -Ypartial-unification turned on? Other FAQs: http://typelevel.org/cats/faq.html
Feels a little like a stricter set of the dependently typed languages?
because you can't really use a nontotal language as a proof system
Agda is total, Idris has a
total flag, and so on
you can wrap in Kleisli and use
>>> though, for now
Also is there a difference between the
*> and >> operators?
do they just come from different typeclasses but do the same thing?
I said
>>>, not >>
but to answer your question
mostly yes
I can give you more details on
>> vs *> if you want
so, definitions first
def *>[F[_]: Applicative, A, B](fa: F[A], fb: F[B]): F[B] = (fa, fb).mapN((_, b) => b)
def >>[F[_]: Monad, A, B](fa: F[A], fb: F[B]): F[B] = fa.flatMap(_ => fb)
does this make sense?
I'm just talking about the one above
anyway, long story short
if you use a concrete type
>> is the same as *> (with one caveat that I'll mention at the end)
if you use an abstract type with a
Monad constraint, they are also the same
but with an
Applicative bound they might not be
in code
def foo[F[_]: Monad] = fa >> fb //pseudocode actually
// is the same as
def foo[F[_]: Monad] = fa *> fb
// is _not_ necessarily the same as
def foo[F[_]: Applicative] = fa *> fb
because the third one could be instantiated with something that doesn't guarantee sequencing of effects, e.g.
ParIO
the other caveat is when writing tail-recursive monadic functions