Add interruption type

[treeowl]

MonadBase and MonadBaseControl instances for transformers reach all the way to the bottom of the stack. Sometimes that's too far. We should offer (modulo naming)

newtype BaseT m a = BaseT
  { runBaseT :: m a }
  deriving (Functor, Applicative, Monad, Generic, Generic1)
deriving instance Show (m a) => Show (BaseT m a)
-- etc.

instance MonadTrans BaseT where
  lift = BaseT

instance MonadBase m (BaseT m) where
  liftBase = BaseT

instance MonadBaseControl m (BaseT m) where
  type StM (BaseT m) a = a
  liftBaseWith f = BaseT $ f runBaseT
  restoreM = BaseT . return

Now StateT s (BaseT (ReaderT e m)) has base monad ReaderT e m.

[treeowl]

Hmm..... Despite the convenience of that definition, it might be better to use this one instead:

instance Monad m => MonadBase (BaseT m) (BaseT m) where
  liftBase = id

instance Monad m => MonadBaseControl (BaseT m) (BaseT m) where
  type StM (BaseT m) a = a
  liftBaseWith f = f id
  restoreM = return

This preserves the property that

(MonadBase x y, MonadBase y z) ====> x ~ y

[mvv]

That would require addition of mtl dep (assuming you still want StateT s (BaseT (ReaderT e m)) to have a non-orphan MonadReader instance), which I'm not in favor of. Maybe it would be better to put it in a separate package?

[Icelandjack]

I was just going to propose this

type    Based :: (Type -> Type) -> Type -> Type
newtype Based base a = Based { unBased :: base a }
 deriving
 newtype (Functor, Applicative, Monad)

instance Monad base => MonadBase base (Based base) where
 liftBase :: base ~> Based base
 liftBase = coerce

instance Monad base => MonadBaseControl base (Based base) where
 type StM (Based base) a = a

 liftBaseWith :: (RunInBase (Based base) base -> base a) -> Based base a
 liftBaseWith f = Base (f unBased)

 restoreM :: a -> Based base a
 restoreM = pure

which allows deriving everything that currently uses CPP pragmas,

deriving via Based []         instance MonadBase []         []
deriving via Based IO         instance MonadBase IO         IO
deriving via Based Maybe      instance MonadBase Maybe      Maybe
deriving via Based STM        instance MonadBase STM        STM
deriving via Based Identity   instance MonadBase Identity   Identity
deriving via Based (Either e) instance MonadBase (Either e) (Either e)
deriving via Based ((->) a)   instance MonadBase ((->) a)   ((->) a)
deriving via Based (ST s)     instance MonadBase (ST s)     (ST s)

deriving via Based IO         instance MonadBaseControl IO         IO
deriving via Based Maybe      instance MonadBaseControl Maybe      Maybe
deriving via Based (Either e) instance MonadBaseControl (Either e) (Either e)
deriving via Based []         instance MonadBaseControl []         []
deriving via Based ((->) a)   instance MonadBaseControl ((->) a)   ((->) a)
deriving via Based Identity   instance MonadBaseControl Identity   Identity
deriving via Based STM        instance MonadBaseControl STM        STM
deriving via Based (ST s)     instance MonadBaseControl (ST s)     (ST s)

[Icelandjack]

I wouldn't add any other instances than that