Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • Sep 05 2019 14:43
    @typelevel-bot banned @jdegoes
  • Jan 31 2019 21:17
    codecov-io commented #484
  • Jan 31 2019 21:08
    scala-steward opened #484
  • Jan 31 2019 18:19
    andywhite37 commented #189
  • Jan 31 2019 02:41
    kamilongus starred typelevel/cats-effect
  • Jan 30 2019 00:01
    codecov-io commented #483
  • Jan 29 2019 23:51
    deniszjukow opened #483
  • Jan 29 2019 23:37
  • Jan 29 2019 23:22
  • Jan 29 2019 20:26
    Rui-L starred typelevel/cats-effect
  • Jan 29 2019 18:01
    jdegoes commented #480
  • Jan 29 2019 17:04
    thomaav starred typelevel/cats-effect
  • Jan 28 2019 17:43
    asachdeva starred typelevel/cats-effect
  • Jan 28 2019 07:12
    alexandru commented #480
  • Jan 28 2019 05:45
    codecov-io commented #482
  • Jan 28 2019 05:35
    daron666 opened #482
  • Jan 27 2019 13:56
    codecov-io commented #481
  • Jan 27 2019 13:46
    lrodero opened #481
  • Jan 27 2019 05:47
    codecov-io commented #460
  • Jan 27 2019 05:37
    codecov-io commented #460
Fabio Labella
@SystemFw
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
a mini Console IO
ah ok, parametricity
we can look at that then
have you heard the term before?
PhillHenry
@PhillHenry
Yes I have a vague notion but not enough to explain it to another person.
Formally.
Fabio Labella
@SystemFw
yeah I don't mean a formal one
the general idea is that you're fully abstract with respect to type parameters, i.e. you have to do the same thing for all instances of them
PhillHenry
@PhillHenry
Yes, that's simple.
Fabio Labella
@SystemFw
say for example def identity[A](a: A): A = a