Fix postmapM law by adding lifts

[Topsii]

Adds lifts, which is similar to Control.Monad.Trans.Class.lift. You could define a Monad instance for FoldM such that

lifts (m >>= f) = lifts m >>= (lifts . f)

instance Monad (Fold a) where
  return = pure
  m >>= f = fold . f <$> m <*> list

instance Monad m => Monad (FoldM m a) where
  return = pure
  m >>= f = postmapM id $ foldM . f <$> m <*> generalize list

We already have hoists, which is similar to Control.Monad.Morph.hoist.
You can also define embeds and squashes, similar to Control.Monad.Morph.embed and Control.Monad.Morph.squash, respectively, satisfying (I believe)

embeds lifts = id

embeds f (lifts m) = f m

embeds :: Monad n => (forall x. m x -> FoldM n a x) -> FoldM m a b -> FoldM n a b
embeds f fld = squashes $ hoists f fld

squashes :: (Monad m) => FoldM (FoldM m a) a b -> FoldM m a b
squashes (FoldM step begin done) = join $ FoldM step' begin' done'
  where
    step' fmax a = pure $ do
      x <- fmax
      step x a
    begin' = pure begin
    done' fmax = pure $ do
      x <- fmax
      done x

As I understand it, these Fold(M) Monad instances are not desirable because they do not stream in constant memory. Hence we only define lifts and use it to fix a law of postmapM.