Eff in data type

[flip111]

I'm trying to translate this

Newly made code (for context)

data EffCheckingFuel :: Effect
type instance DispatchOf EffCheckingFuel = Static NoSideEffects
newtype instance StaticRep EffCheckingFuel = EffCheckingFuel Fuel
runCheckingFuel :: Fuel -> Eff (EffCheckingFuel : es) a -> Eff es a
runCheckingFuel fuel = evalStaticRep (EffCheckingFuel fuel)

data EffUnique :: Effect
type instance DispatchOf EffUnique = Static NoSideEffects
newtype instance StaticRep EffUnique = EffUnique [Unique]
runUnique :: [Unique] -> Eff (EffUnique : es) a -> Eff es a
runUnique uniques = evalStaticRep (EffUnique uniques)
freshUniqueEff :: EffUnique :> es => Eff es Unique
freshUniqueEff = stateStaticRep \case
  EffUnique []       -> error "fresh: empty list"
  EffUnique (x : xs) -> (x, EffUnique xs)

M no longer used monad

-- Old code
type M = CheckingFuelMonad (SimpleUniqueMonad)
run :: LabelMapM a -> I.M (IdLabelMap, a)
run (LabelMapM f) = f M.empty -- >>=  pure -- . snd

-- new code (not correct yet i guess)
run :: EffCheckingFuel :> es => EffUnique :> es => LabelMapM a -> Eff es (IdLabelMap, a)
run (LabelMapM f) = pure $ f M.empty

The data type in question

-- Old
data LabelMapM a = LabelMapM (IdLabelMap -> I.M (IdLabelMap, a))

-- New
data LabelMapM a es = LabelMapM (IdLabelMap -> Eff es (IdLabelMap, a))

Missing the constraint on es. Tried the following

{-# LANGUAGE DatatypeContexts #-}

data EffUnique :> es => LabelMapM a es = LabelMapM (IdLabelMap -> Eff es (IdLabelMap, a))

I got the following comment from someone else:

Usually you don't want to use DatatypeContexts, because they don't do what you expect or want. Which is why they were removed/hidden behind an extension (they were in Haskell98). Tthe main problem with them is they only apply when making values; they are not available when using those values. That requires an instance dictionary to carry around the proof of the constraint

Also this GHC warning

-XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.

What is the right approach to model this?