fixup! io-classes: Add MonadUnique to support Data.Unique

Author: LSLeary

io-classes/CHANGELOG.md

@@ -3,6 +3,7 @@
 ### next release
 
 * Added module `Control.Monad.Class.MonadUnique` generalising `Data.Unique`.
+* mtl: Added module `Control.Monad.Class.MonadUnique.Trans` providing monad transformer instances for `MonadUnique`.
 
 ### 1.8.0.1
 

io-classes/io-classes.cabal

@@ -175,6 +175,7 @@ library mtl
                    ,  Control.Monad.Class.MonadTime.SI.Trans
                    ,  Control.Monad.Class.MonadTimer.Trans
                    ,  Control.Monad.Class.MonadTimer.SI.Trans
+                   ,  Control.Monad.Class.MonadUnique.Trans
     build-depends:    base,
                       array,
                       mtl,

io-classes/mtl/Control/Monad/Class/MonadUnique/Trans.hs

@@ -0,0 +1,56 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
+{-# LANGUAGE TypeFamilies, DerivingVia, UndecidableInstances #-}
+
+module Control.Monad.Class.MonadUnique.Trans () where
+
+import Data.Kind (Type)
+
+import Control.Monad.Cont (ContT)
+import Control.Monad.Except (ExceptT)
+import Control.Monad.RWS.Lazy qualified as Lazy
+import Control.Monad.RWS.Strict qualified as Strict
+import Control.Monad.State.Lazy qualified as Lazy
+import Control.Monad.State.Strict qualified as Strict
+import Control.Monad.Trans (MonadTrans(..))
+import Control.Monad.Writer.Lazy qualified as Lazy
+import Control.Monad.Writer.Strict qualified as Strict
+
+import Control.Monad.Class.MonadUnique
+
+
+type Trans
+  :: ((Type -> Type) -> (Type -> Type))
+  ->  (Type -> Type) -> (Type -> Type)
+newtype Trans t m a = Trans (t m a)
+  deriving (Functor, Applicative, Monad, MonadTrans)
+
+instance (MonadTrans t, MonadUnique m) => MonadUnique (Trans t m) where
+  type Unique (Trans t m) = Unique m
+  newUnique  = lift newUnique
+  hashUnique = hashUnique @m
+
+
+deriving via Trans (ContT r) m
+  instance MonadUnique m => MonadUnique (ContT r m)
+
+deriving via Trans (ExceptT e) m
+  instance MonadUnique m => MonadUnique (ExceptT e m)
+
+deriving via Trans (Lazy.RWST r w s) m
+  instance (MonadUnique m, Monoid w) => MonadUnique (Lazy.RWST r w s m)
+
+deriving via Trans (Strict.RWST r w s) m
+  instance (MonadUnique m, Monoid w) => MonadUnique (Strict.RWST r w s m)
+
+deriving via Trans (Lazy.StateT s) m
+  instance MonadUnique m => MonadUnique (Lazy.StateT s m)
+
+deriving via Trans (Strict.StateT s) m
+  instance MonadUnique m => MonadUnique (Strict.StateT s m)
+
+deriving via Trans (Lazy.WriterT w) m
+  instance (MonadUnique m, Monoid w) => MonadUnique (Lazy.WriterT w m)
+
+deriving via Trans (Strict.WriterT w) m
+  instance (MonadUnique m, Monoid w) => MonadUnique (Strict.WriterT w m)
+