A monad transformer based on `NonEmptyT`

nonemptytrans.hs

-- Note: The same warnings about ListT's poor behavior apply to this transformer.
-- https://wiki.haskell.org/ListT_done_right

import Data.List.NonEmpty
import Control.Monad
import Control.Monad.List

newtype NonEmptyT m a = NonEmptyT { unNonEmptyT :: m (NonEmpty a) }

instance Functor m => Functor (NonEmptyT m) where
    fmap f (NonEmptyT xx) = NonEmptyT $ fmap (fmap f) xx

instance Applicative m => Applicative (NonEmptyT m) where
    pure x = NonEmptyT $ pure (x :| [])
    (NonEmptyT ff) <*> (NonEmptyT xx) = NonEmptyT $ (<*>) <$> ff <*> xx

instance Monad m => Monad (NonEmptyT m) where
    return = pure
    (NonEmptyT xx) >>= ff = NonEmptyT $ do
                              xs <- xx
                              ys <- mapM (unNonEmptyT . ff) xs
                              return $ join ys

instance MonadTrans NonEmptyT where
    lift m = NonEmptyT $ fmap (\x -> x :| []) m

testList :: ListT Maybe a -> ListT Maybe a
testList (ListT (Just [])) = ListT Nothing
testList x = x

testList' :: [a] -> NonEmptyT Maybe a
testList' [] = NonEmptyT Nothing
testList' (x:xs) = NonEmptyT $ Just (x :| xs)