Haskell 递归地将多个列表动态转置为单个列表

Question

不确定“动态”是否适合这个问题。

我一直在努力寻找压缩多个列表的解决方案 进入一个列表，但我开始认为我的方法是不可能的。 它适用于两个列表，但不适用于三个（可能不会超过三个）。 该函数应该作为transpose 工作，但会产生一个整数列表和 不是整数列表的列表。但如果它产生一个列表列表，它也会 工作。理论上，该函数应该适用于任意数量的列表。

例如 [1,2,3] myTranspose [4,5,6] myTranspose [7,8,9] 应该会导致 [1, 4, 7, 2, 5, 8, 3, 6, 9]

这可能吗？

到目前为止我的尝试：

myTranspose :: [Int] -> [Int] -> [Int]
myTranspose [] []         = []
myTranspose [x] []        = [x]
myTranspose [] [y]        = [y] 
myTranspose [x] [y]       = [x,y]
myTranspose (x:xs) [y]    = (x:y:xs)
myTranspose [x] (y:ys)    = (x:y:ys)
myTranspose (x:xs) (y:ys) = [x,y] ++ zip' xs ys

编辑我的实际问题：

我应该从一开始就问这个，但我认为它会 将问题转换为整数列表更简单。对此感到抱歉。

我有一个数据类型 Function 和一个链接 Functions 的函数 一起：

data Function where
    (|||) :: Function -> Function -> Function
    A ::  Char -> Function
    B ::  Int  -> Function

chain :: Function -> Function -> Function
chain f1 f2 = f1 ||| f2

而且我还有一个功能应该像我上面描述的那样工作：

(<|||>) :: Funcion -> Function -> Function
 ...something like this..
(<|||>) (p1 ||| p2) (q1 ||| q2)     =  (p1 <|||> q1) ||| (p2 <|||> q2)
(<|||>) (p1 ||| p2)       q          =  p1 <|||> p2 ||| q 
(<|||>)       p         (q1 ||| q2)  =  p  ||| q1 <|||> q2
(<|||>)       p           q          =  p  ||| q

我设法用普通的列表和普通的 像moonGoose建议的转置功能。但问题是 如果我这样做，编译器会抱怨没有足够的内存 那样。 函数调用看起来像这样，除了列表是 非常大：

transpose ((A 'a' ||| B 5 ||| A 'n')   <|||>  
             (A 'o' ||| B 3 ||| A 'p') <|||>
            (A 'i' ||| B 0 ||| A 'l'))

但是当我使用“我的”列表功能和不完美的自定义运行程序时 transpose-function 编译器不会抱怨。我的想法是，这与懒惰有关。这可能是问题吗？ 感谢您的帮助。

Answer 1

也许你可以动态地这样做

zwh :: [[a]] -> [a]
zwh xss = if any ((== 0) . length) xss then []
                                       else hs ++ zwh ts
          where
          (hs,ts) = foldr (\(hs',ts') (rs,qs) -> (hs':rs,ts':qs)) ([],[]) hts
          hts     = (,) <$> head <*> tail <$> xss

λ> zwh [[1,2,3],[4,5,6],[7,8,9]]
[1,4,7,2,5,8,3,6,9]
λ> zwh [[1,2],[4,5,6],[7,8,9]]
[1,4,7,2,5,8]

或者根据a的类型，如果可以包含EQ a =>约束，它会进一步简化为

zwh :: Eq a => [[a]] -> [a]
zwh xss = if any (== []) xss then []
                             else hs ++ zwh ts
          where
          (hs,ts) = foldr (\(hs',ts') (rs,qs) -> (hs':rs,ts':qs)) ([],[]) hts
          hts     = (,) <$> head <*> tail <$> xss

Answer 2

编辑后，我想你想要这样的东西？正如 chi 在评论中已经提到的那样，这令人困惑，因为 (|||) 似乎是关联的，这可能是您遇到的问题的核心。如果它是关联的，那么底层结构是（非空）类似列表的，所以我们知道如何对它们进行转置并将它们轻松粘合在一起等。但是如果它不是关联的，那么表示是树状的喜欢，而且我认为您不能规范地映射/转置树（例如，A 0 <> A 1 <> A 2 = (A 0 ||| A 1) ||| A 2 或 A 0 ||| (A 1 ||| A 2)？这很重要，前提是 (|||) 不是关联的）。

import Control.Lens.Iso (iso, mapping, under)
import qualified Data.List.NonEmpty as NE
import Data.List.NonEmpty (NonEmpty)
import Data.Semigroup (sconcat)

instance Semigroup Function where
  (<>) = (|||)

transposeFuncs :: NonEmpty Function -> Function
transposeFuncs = sconcat . under (mapping $ iso reify reflect) NE.transpose
  where
    reflect :: Function -> NonEmpty (Either Char Int)
    reflect (a ||| b) = reflect a <> reflect b
    reflect (A a)     = pure $ Left  a
    reflect     (B b) = pure $ Right b
    reify :: NonEmpty (Either Char Int) -> Function
    reify = sconcat . NE.map (either A B)

transposeFuncs $ NE.fromList 
  [ A 'a' ||| B  5  ||| A 'n'
  , A 'o' ||| B  3  ||| A 'p'
  , A 'i' ||| B  0  ||| A 'l'
  ]
  ==  A 'a' ||| A 'o' ||| A 'i'
  ||| B  5  ||| B  3  ||| B  0
  ||| A 'n' ||| A 'p' ||| A 'l' 

编辑： 如果您希望在数据类型中表达关联性，那么您将使用类似以下的内容。看看当类型与意图匹配时有多好；每个（语义）值只有一种表示形式。如果你允许一个身份，那么它会更干净。

import Control.Lens (makeWrapped, mapping, under, _Unwrapped')
import Data.List.NonEmpty (NonEmpty, transpose)
import Data.Semigroup (sconcat)

data FuncAtom
  = A Char
  | B Int

newtype Function
  = FCompose (NonEmpty FuncAtom)
  deriving Semigroup via NonEmpty FuncAtom
makeWrapped ''Function

transposeFuncs :: NonEmpty Function -> Function
transposeFuncs = sconcat . under (mapping _Unwrapped') transpose