content: {-# LANGUAGE RebindableSyntax, FlexibleInstances,
               MultiParamTypeClasses, FunctionalDependencies #-}
  
  -- #1537
  
  module Foo where
  import qualified Prelude
  import Prelude hiding (Monad(..))
  
  import Control.Applicative (Applicative(..))
  import Control.Monad (liftM, ap)
  
  newtype Identity a = Identity { runIdentity :: a }
  
  instance Prelude.Functor Identity where
      fmap = liftM
  
  instance Applicative Identity where
      pure = Identity
      (<*>) = ap
  
  instance Prelude.Monad Identity where
      m >>= k  = k (runIdentity m)
  
  class Bind m1 m2 m3 | m1 m2 -> m3 where
    (>>=) :: m1 a -> (a -> m2 b) -> m3 b
  
  class Return m where
    returnM :: a -> m a
    fail   :: String -> m a
  
  instance Bind Maybe [] [] where
    Just x  >>= f = f x
    Nothing >>= f = []
  
  instance              Bind Identity a a   where m >>= f = f (runIdentity m)
  instance Functor a => Bind a Identity a   where m >>= f = fmap (runIdentity . f) m
  
  instance Prelude.Monad m => Bind m m m where (>>=) = (Prelude.>>=)
  
  instance Return [] where
    returnM x = [x]
    fail _   = []
  
  return :: a -> Identity a
  return = Prelude.return
  
  should_compile :: [Int]
  should_compile = do
    a <- Just 1
    b <- [a*1,a*2]
    return (b+1)