Unintuitive Functor and Applicative instances

[rihardsk]

I had expected that S.map and fmap would work the same. E.g., to my mind these should have been equivalent:

x = S.map (+1) $ S.each [1..10]
x' = fmap (+1) $ S.each [1..10] -- this gives a compiler error

Because that's what happens to lists with map and fmap. Instead fmap only affects the result of the stream.

Similarly, with the Applicative instance:

y = S.zipWith (/) (S.each [1..10]) (S.each [2..11])
y' = (/) <$> S.each [1..10] <*> S.each [2..11] -- this gives a compiler error

What is the motivation behind such an implementation? There's certainly a downside for me here since, it seems, I can't have a general function working on Functors that would do the same thing for lists and streams.

[ocharles]

It's not possible to have fmap and Applicative to do what you want because the kinds don't match. Applicative combines the last type variable, but in Stream the elements are (part of) the first type variable:

Stream (Of a) m r
           ^    ^
           |    `--- This is what `Functor` and `Applicative` uses
           `--- This is what S.map/S.zipWith uses

Then note what you get from S.each:

each :: f a -> Stream (Of a) m () 

Hopefully there it's clear why fmap (+1) isn't going to work - fmap operates on the () that each returns, not the Of a stream type.

[danidiaz]

The pipes library includes a newtype that shuffles the Producer type variables around and is a proper ListT: http://hackage.haskell.org/package/pipes-4.3.9/docs/Pipes.html#t:ListT

[treeowl]

We could add a proper ListT, although the original author of this package wasn't a fan.

[rihardsk]

@ocharles yup, it's clear that Functor and Applicative work on the result part of the type. My question was about the reasoning behind this - why do the instances work this way? My argument was that at least on the surface it seems it would make more sense to have it work like it does for lists (at least in my usecase where i have some functions on Functors that I would like to use with Streams).

I think that a newtype with a changed behavior would indeed be useful.

[chessai]

see PR #71 . A few small questions posed there; would love your input.

[chessai]

I'm not sure this even needs to be documented. If you understand haskell's kind system, then this makes perfect sense. Should this be closed?

[andrewthad]

I think it would be fine attach documentation to the Functor instance of Stream. Something like "Operates covariantly on the stream result, not on its elements".

[chessai]

see #81