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]]
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?
Formally.
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
without cheating (asInstanceOf, nontermination, etc)
parametricity restricts the state space of possible implementations, and it's a big reason for the "if it compiles it works" meme (which obviously isn't strictly true, but it hints at the reduction of the solution space that types give you)
so, parametricity is a good thing
does that also make sense?
as to why you don't want to do that?
(Yes)
is not the the code is dirty, is that now identity suffers from all the problems of
identity: Int => Int
i.e the types stopped helping you in restricting the solution space
anyway, that is not desirable
does that make sense?
without even datatype and interpreter
and no exception handling either (let alone concurrency and all the things that real IO has)
just a referentially transparent representation of synchronous side effects
I guess what I am struggling with is if map is defined as:
map[A, B]: IO[A] => (A => B) => IO[B]
and flatMap as
flatMap[A, B]: IO[A] => (A => F[B]) => IO[B]
if they both result in IO[B] then why does one necessarily run a program and one does not?
also, you have to have
IO in A => IO[B] in flatMap, not F
class IO[A](...) {
def map[B](f: A => B): IO[B]
def flatMap[B](f: A => IO[B]): IO[B]
}
object IO {
def delay(a: => A): IO[A]
}
which is the most corners you can cut in terms of feature, and also does not distinguish between
pureand delay (picks delay, which is the most powerful)
let me know if that makes sense so we can go about implementing that, and you'll see why
map fundamentally cannot do what you want
(assuming you stick to the principle that all effects are suitably wrapped in
IO)