Haskell中任何顺序或维度的列表理解

Question

考虑以下程序。

chars = [" "] ++ ["A"] ++ ["B"] ++ (repeat "ABCD")

f :: Int -> [(Char,Int)]
f n = (,) <$> (chars !! n) <*> [1..3]

g :: Int -> [[(Char,Int)]]
g 1 = (\a     -> [a    ]) <$> (f 1)
g 2 = (\a b   -> [a,b  ]) <$> (f 1) <*> (f 2)
g 3 = (\a b c -> [a,b,c]) <$> (f 1) <*> (f 2) <*> (f 3)
-- g n = (\x1 x2 ... xn -> [x1,x2,...,xn]) <$> (f 1) <*> (f 2) <*> ... (f n)

我们怎样才能写出g n，一般对于所有n > 0，而不像上面那样显式地输入展开式，理想情况下只使用Prelude（和Control.Applicative，如果需要的话）？请注意，对于所有 n>3，f n = f (n-1)，因此可以递归地定义 g。

输出是这样的（忽略漂亮的打印）：

> g 1
[ [ ( 'A' , 1 ) ] , [ ( 'A' , 2 ) ] , [ ( 'A' , 3 ) ] ]

> g 2
[ [ ( 'A' , 1 ) , ( 'B' , 1 ) ]
, [ ( 'A' , 1 ) , ( 'B' , 2 ) ]
, [ ( 'A' , 1 ) , ( 'B' , 3 ) ]
, [ ( 'A' , 2 ) , ( 'B' , 1 ) ]
, [ ( 'A' , 2 ) , ( 'B' , 2 ) ]
, [ ( 'A' , 2 ) , ( 'B' , 3 ) ]
, [ ( 'A' , 3 ) , ( 'B' , 1 ) ]
, [ ( 'A' , 3 ) , ( 'B' , 2 ) ]
, [ ( 'A' , 3 ) , ( 'B' , 3 ) ]
]

> g 3
[ [ ( 'A' , 1 ) , ( 'B' , 1 ) , ( 'A' , 1 ) ]
, [ ( 'A' , 1 ) , ( 'B' , 1 ) , ( 'A' , 2 ) ]
...
, [ ( 'A' , 3 ) , ( 'B' , 3 ) , ( 'D' , 3 ) ]
]

Answer 1

g n = traverse f [1 .. n]

traverse 在前奏曲中（至少在过去几年中）。

因为这有点不明显，所以我是这样到达那里的：

1. 我注意到您将 f 应用于从 1 到 n 的数字，所以我从 map f [1 .. n] 开始。

2. 这产生了一个[[(Char, Int)]]，它是所需的结果类型，但它需要有点……转向侧面并相乘。您想要来自内部列表中值的非确定性选择的所有列表。非确定性选择是[] 的Applicative 实例的本质，事实证明sequence 在[[a]] 类型上的操作正是“生成您从组合组合元素中获得的所有列表”内部列表”。这让我去了sequence $ map f [1 .. n]。

3. 但是sequence 和map 这对很常见，以至于有一个操作可以同时执行这两个操作。 sequence . map f === traverse f。因此，应用该规则简化了结果。 traverse f [1 .. n]。

Answer 2

g n = mapM f [1..n]

如何到达那里。

您的示例等效地使用列表理解语法编写为

g :: Int -> [[(Char,Int)]]
g 1 = [[a    ] | a <- (f 1)]
g 2 = [[a,b  ] | a <- (f 1), b <- (f 2)]
g 3 = [[a,b,c] | a <- (f 1), b <- (f 2), c <- (f 3)]
-- g n = [[a,b,c, ... , z] | a <- (f 1), b <- (f 2), ... , z <- (f n)]

这正是 sequence 在 Monad Comprehension 语法中的定义方式：

sequence [as,bs,cs, ... , zs] = [[a,b,c, ... , z] | a <- as, b <- bs, ... , z <- zs]

因此

g n = sequence [(f 1), (f 2), ... , (f n)]
    = sequence $ map f [1..n]

这又是mapM 的定义（或其等价物）。

(mapM 现在也被称为 traverse，对于也是 Applicatives 和 Monads 的类型。Haskell 列表 [] 是两者，无论如何，我发现名称 mapM 更清晰，更短类型）。

---

这是一个支持未被充分认识的列表理解和 Monad 理解语法的公共服务公告。

我实际上对 g n = sequence $ map f [1..n] 很好，并且没有任何特别想进一步缩短它的冲动，因为我发现它比这两种选择都更清晰。

Answer 3

像这样：

g 0 = [[]]
g n = (\xs x -> xs ++ [x]) <$> g (n - 1) <*> f n

或者更复杂，但也更高效：

g = map ($ []) . go
  where
    go :: Int -> [[(Char,Int)] -> [(Char,Int)]]
    go 0 = [id]
    go n = (\xs x -> xs . (x:)) <$> go (n - 1) <*> f n

这使用 Hughes 列表/差异列表来避免 the quadratic slowdown 或 \xs x -> xs ++ [x]。