在Haskell列表理解中组织元组序列

Question

你好亲爱的社区,

我正在尝试在Haskell List理解中组织元组序列.

例如,我得到以下列表理解:

[ (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并且finaly号码.

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

Answer 1

该订单的的x <- list列表中理解的语句是很重要的.如果你写:

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

这相当于y作为内部循环的嵌套for 循环.因此,与循环的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')]

(添加了新行以便于验证)