typelevel/cats-effect

Most discussion is on Typelevel Discord: https://discord.gg/bSQBZA3Ced

PhillHenry

@PhillHenry

Can I please ask a noddy question?
I get the monad laws and I get that you have to flatMap effects to make them "happen".
What I don't get is: why flatMap? Why can't I, say,. map over an fs2.Stream of effects and have them "executed"? Is the choice of flatMap arbitrary or are there mathematical laws at play here? If so, what are these laws?

Fabio Labella

@SystemFw

@PhillHenry I'm not exactly sure what you mean

ultimately an effect is represented as F[A]

so map: F[A] => (A => B) => F[B] cannot execute further effects in the function simply because there are none there

hence why A => F[B] ,which on more fundamental level, it's the general concept of a continuation when you represents effects in this style (programs as values)

you can have other combinators, but they ultimately resolve to flatmap

e.g. with Stream you have evalMap: Stream[F, A] => (A => F[B) => Stream[F, B]

which is flatMap(a => Stream.eval(f(a))

you can find a similar structure to flatMap in strict side-effecting languages as well, if you squint

Fabio Labella

@SystemFw

i.e. we look at this capability as primitive

val a = readLine
printLine a
a.toUpperCase

but you can construct it as syntactic sugar over snd : a -> b -> b or more generally next: a -> (a -> b) -> b assuming a strict side-effecting language

similarly to how for comprehensions work with flatMap

PhillHenry

@PhillHenry

@SystemFw I guess as a newbie I don't have the mental model. I've learned by rote that one must flatMap but I can see why after years of mapping over Scala collections one might naively think this:

    val printEffect:  Int => IO[Unit]     = x => IO { println(x) }
    val printEach:    Pipe[IO, Int, Unit] = { _.map(x => printEffect(x)) }
    printEach(Stream(1, 2, 3, 4, 5)).compile.toList

prints out the numbers 1 to 5.
It is, of course, wrong. But why (other than "it just is") is currenlty eluding me.
Can you please expand on why A => F[B] is a program and F[A] => (A => B) => F[B] is not?

Fabio Labella

@SystemFw

A => B is not

well, B

your code does not type check

so, the starting point is that println doesn't exist, as you note

println: Unit

what we have is purePrintLn: IO[Unit]

is that clear? (I think it is, but better to check)

@PhillHenry

btw I'm writing a blog post series on the paradigm, from the ground up, which I think will be helpful eventually

PhillHenry

@PhillHenry

Not sure what you mean by "does not type check". Sure, it's a snipped but I'm running it as we speak.

Yes, a "ground up" blog would help enormously. I look forward to it!

Fabio Labella

@SystemFw

you don't have value discard in your options, or the type error will be caught :)

PhillHenry

@PhillHenry

Ah, right! Bad me...

Fabio Labella

@SystemFw

you code compile in the same way as def foo: Unit = 3 does

PhillHenry

@PhillHenry

Yes, I see your point

Fabio Labella

@SystemFw

but I can break it down ofc

map: F[A] => (A => B) => F[B]

in your case F is Stream

so map: Stream[IO, A] => (A => B) => Stream[IO, B]

A is Int

A => B unifies with Int => IO[Unit]

so your Pipe is Pipe[IO, Int, IO[Unit]]

PhillHenry

@PhillHenry

With you so far.

Fabio Labella

@SystemFw

so it emits programs, but doesn't execute them, which btw is useful sometimes! The point of the paradigm is all about being able to juggle doing (execute this now), with being (use this effect as a value, which gets executed "later")

PhillHenry

@PhillHenry

Maybe I am being as thick as a whale omlette but this "it emits programs, but doesn't execute them" is baffling me. What prevents map from executing them?

Fabio Labella

@SystemFw

btw I think it's easier if you focus on IO first, because with Stream you have two types at play (Stream and IO), which I think is confusing

look at IO first

map has no idea that what you return is a program

just think about IO for a minute

the type is map[A, B]: IO[A] => (A => B) => IO[B]

IO is a datatype, which gets interpreted

and map is fully parametric on A and B

so you cannot use a characteristic of B to do special things

but you are saying for some special Bs, i.e. B = IO[C] , you want to do something else

instead, when you do ioA.map(printEffect), it gets treated as any other B, i.e. you get IO[IO[Unit]]

PhillHenry

@PhillHenry

Struggling with "you cannot use a characteristic of B to do special things".

Fabio Labella

@SystemFw

let's do this

let's implement a small language

Where communities thrive

People

Repo info

Activity