在 Haskell 列表推导中组织元组序列答案

【问题标题】：Organize the sequence of tuple in a Haskell List comprehension在 Haskell 列表推导中组织元组序列
【发布时间】：2018-03-10 06:28:40
【问题描述】：

亲爱的社区，你好，

我正在尝试在 Haskell 列表理解中组织元组序列。

例如我得到了以下列表理解：

[ (a,b,c,d) | a <- [0, 50, 100, 150, 200]
            , b <- ['a', 'b', 'c']
            , c <- [True, False]
            , d <- ['A', 'B']
            ]

然后得到：

[ (0, 'a', True, 'A'), (0, 'a', True, 'B'), (0, 'a', False, 'A')
, (0, 'a', False, 'B'), (0, 'b', True, 'A'), (0, 'b', True, 'B')
, (0, 'b', False, 'A'), (0, 'b', False, 'B'), (0, 'c', True, 'A')
,(0, 'c', True, 'B'), (0, 'c', False, 'A')..

现在我想要如下序列：

[ (0, 'a', True, 'A'), (0, 'a', True, 'B'), (0, 'b', True, 'A')
, (0, 'b', True, 'B'), (0, 'c' ,True, 'A'), (0, 'c', True, 'B')
, (0, 'a', False, 'A'), (0, 'a', False, 'B')..

这意味着：首先是大写字母'A' 和'B' 之间的折衷，然后是小写字母'a','b','c' 之间的折衷，作为倒数第二个布尔值True 之间的折衷， False 最后确定数字。

不幸的是，我完全不知道如何实现这些，我想知道如何使用元组 [(a,b,c)] 操作列表的序列。

【问题讨论】：

标签： list haskell tuples list-comprehension

【解决方案1】：

列表理解中x <- list 语句的顺序很重要。如果你写：

[expr | x <- list1, y <- list2]

这相当于一个嵌套的 for 循环，y 是内部循环。因此，带有循环的 Python 等效项是：

for x in list1:
    for y in list2:
        expr

因此，在外部循环选择下一个值之前，内部循环已完全耗尽。

所以我们需要重新排序语句，这样我们首先选择d，然后是b，然后是c，最后是a。所以这意味着我们转向：

[(a,b,c,d)| a <- [0,50..200], b <- "abc", c <- [True,False], d <-"AB"]

（我使列表的符号更短）

进入：

-- [(a,b,c,d)| a <- [0,50..200], b <- "abc", c <- [True,False], d <-"AB"]
--             |                  \_________/_____              |
--             |                   ________/      \             |
--             |                  /                \            |
   [(a,b,c,d)| a <- [0,50..200], c <- [True,False], b <- "abc", d <- "AB"]

（评论只是为了形象化差异）

生成：

Prelude> [(a,b,c,d)| a <- [0,50..200], c <- [True,False], b <- "abc", d <- "AB"]
[(0,'a',True,'A'),
 (0,'a',True,'B'),
 (0,'b',True,'A'),
 (0,'b',True,'B'),
 (0,'c',True,'A'),
 (0,'c',True,'B'),
 (0,'a',False,'A'),
 (0,'a',False,'B'),
 (0,'b',False,'A'),
 (0,'b',False,'B'),
 (0,'c',False,'A'),
 (0,'c',False,'B'),
 (50,'a',True,'A'),
 (50,'a',True,'B'),
 (50,'b',True,'A'),
 (50,'b',True,'B'),
 (50,'c',True,'A'),
 (50,'c',True,'B'),
 (50,'a',False,'A'),
 (50,'a',False,'B'),
 (50,'b',False,'A'),
 (50,'b',False,'B'),
 (50,'c',False,'A'),
 (50,'c',False,'B'),
 (100,'a',True,'A'),
 (100,'a',True,'B'),
 (100,'b',True,'A'),
 (100,'b',True,'B'),
 (100,'c',True,'A'),
 (100,'c',True,'B'),
 (100,'a',False,'A'),
 (100,'a',False,'B'),
 (100,'b',False,'A'),
 (100,'b',False,'B'),
 (100,'c',False,'A'),
 (100,'c',False,'B'),
 (150,'a',True,'A'),
 (150,'a',True,'B'),
 (150,'b',True,'A'),
 (150,'b',True,'B'),
 (150,'c',True,'A'),
 (150,'c',True,'B'),
 (150,'a',False,'A'),
 (150,'a',False,'B'),
 (150,'b',False,'A'),
 (150,'b',False,'B'),
 (150,'c',False,'A'),
 (150,'c',False,'B'),
 (200,'a',True,'A'),
 (200,'a',True,'B'),
 (200,'b',True,'A'),
 (200,'b',True,'B'),
 (200,'c',True,'A'),
 (200,'c',True,'B'),
 (200,'a',False,'A'),
 (200,'a',False,'B'),
 (200,'b',False,'A'),
 (200,'b',False,'B'),
 (200,'c',False,'A'),
 (200,'c',False,'B')]

（添加了新行以便于验证）

【讨论】：