[Haskell-cafe] MonadComprehensions madness

[Albert Y. C. Lai]

I am just starting to learn MonadComprehensions and I'm following its 
type rules to their logical conclusion.

So I can have

   [ x | x <- "abc", then group by EXPR using PNT ]

where EXPR is an expression of my choosing, PNT is a function of type

   forall a. (a -> E) -> [a] -> M (F a)

where E is the type of EXPR, M is a Monad instance of my choosing, and F 
is a Functor instance of my choosing.  (And even the [a] can be replaced 
by N a, as long as "abc" has type N Char.)

(My freedom over M and F isn't quite documented in the GHC user's guide, 
but there is very little you can't discover by putting a few typed holes 
here and there >:) )

So I choose EXPR = ord x, E = Int, M = IO, F = IntMap, so I can have:

{-# LANGUAGE MonadComprehensions, TransformListComp #-}

module F where

import Data.Char (chr, ord)
import qualified Data.IntMap.Strict as IntMap

foo :: IO (IntMap.IntMap Char)
foo = [ x | x <- "a\r\n", then group by ord x using whee ]

whee :: (a -> Int) -> [a] -> IO (IntMap.IntMap a)
whee f xs = do
     print (map (chr . f) xs)
     return (IntMap.fromList (zip (map f xs) (reverse xs)))

Warning: I have only proved that it type-checks; I have not understood 
what good it does. >:)