我想定义一个类型，它包含一个容器和容器的类型，以及一些操作，比如对容器执行外积，Map容器及其值，以及各种标准类（Functor、Applicative、Monad、MonadTrans等）提供的所有内容。
这是类型的定义和我提到的两个操作：

-- metacontainer
newtype MC c a = MC { runMetaContainer :: c a } deriving Show

-- outer product
cross :: (Functor f1, Functor f2) => (a -> b -> c) -> MC f1 a -> MC f2 b
  -> MC (Compose f1 f2) c
cross f (MC c1) (MC c2) = MC $ Compose $ (\x -> f x <$> c2) <$> c1

-- map the container
hoist :: (c1 a -> c2 b) -> MC c1 a -> MC c2 b
hoist f (MC c) = MC $ f c

这种方法是有效的，但是当我cross两个MC时，得到的容器是由一些嵌套的 * 不必要的 * 容器组成的，比如Compose或Identity。
请看这个例子：

let list = MC [1,2,3]          :: MC [] Int
let justStr = MC $ Just "hey"  :: MC Maybe String
let n = MC $ Identity 5        :: MC Identity Int

let dblLst = cross (*) list n  :: MC (Compose [] Identity) Int
let justStrList = cross (\x str -> str ++ " " ++ show x)
  dblLst justStr               :: MC (Compose (Compose [] Identity) Maybe) String

因为justStrList的类型中有那些不必要的Compose s和Identity s，所以我不能简单地做类似于...

hoist (\lstMbStr -> lstMbStr & filter isJust & map fromJust) justStrList
-- error
--     • Couldn't match type ‘Compose (Compose [] Identity) Maybe’
--                      with ‘[]’
--       Expected: MyType [] (Maybe b0)
--         Actual: MyType (Compose (Compose [] Identity) Maybe) String

有什么方法可以将容器"标准化"吗？
在本例中，我想将(Compose (Compose [] Identity) Maybe) String转换为等效的[Maybe String]。
我试过用夏丽瑶的方法，但是对我不起作用。
这是我的全部代码：

import Data.Maybe ( catMaybes )
import Data.Functor.Identity ( Identity(..) )
import Data.Functor.Compose ( Compose, Compose(..) )
import Data.Coerce (coerce, Coercible)

-- metacontainer
newtype MC c a = MC { runMetaContainer :: c a }

-- outer product
cross :: (Functor f1, Functor f2) => (a -> b -> c) -> MC f1 a -> MC f2 b
  -> MC (Compose f1 f2) c
cross f (MC c1) (MC c2) = MC $ Compose $ (\x -> f x <$> c2) <$> c1

-- map the container
hoist :: (c1 a -> c2 b) -> MC c1 a -> MC c2 b
hoist f (MC c) = MC $ f c

coerceMC :: Coercible (c a) (d a) => MC c a -> MC d a
coerceMC = coerce

main :: IO ()
main = do
    let list = MC [1,2,3]
    let justStr = MC $ Just "hey"
    let n = MC $ Identity 5

    let dblLst = cross (*) list n
    let justStrList = cross (\x str -> str ++ " " ++ show x) dblLst justStr
    
    print $ hoist catMaybes (coerceMC justStrList)

这是我收到的错误信息

error:
    • Couldn't match type: [Char]
                     with: Maybe b0
      Expected: MC (Compose (Compose [] Identity) Maybe) (Maybe b0)
        Actual: MC (Compose (Compose [] Identity) Maybe) [Char]
    • In the first argument of ‘coerceMC’, namely ‘justStrList’
      In the second argument of ‘hoist’, namely ‘(coerceMC justStrList)’
      In the second argument of ‘($)’, namely
        ‘hoist catMaybes (coerceMC justStrList)’

如果我试图向GHC询问coerceMC justStrList的类型，它会说它是MC d0 [Char]，其中'd0'是一个不明确的类型变量。
如果我尝试启用PartialTypeSignatures扩展，它会说它无法匹配类型的表示：[Identity (Maybe [Char])]与以下值的关系：d0 [Char].
我不知道如何表达我希望coerceMC justStrList拥有的类型，它应该是MC [Maybe] String，除非它是一个无效的类型，因为种类不匹配。
我尝试强制提升函数（hoist f (MC c) = MC $ f $ coerce c）内部的容器，因为我知道如何表达c的强制（从Compose (Compose [] Identity) Maybe String到[Maybe String]），但它仍然不起作用。
我设法让它与hoist的定义一起工作：hoist f (MC c) = MC $ f (coerce c :: [Maybe String])，但我希望找到一个解决方案，如果f的类型存在，则可以从f的类型推断强制类型。