組織在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',之間折衷,'c'，作爲倒數第二個布爾值True,False之間的折衷和最終的數字。

不幸的是，我完全不知道如何實現這些，我想知道如何操作元組的列表[(a,b,c)]列表的序列。

來源

2017-09-28 M Nazar

order of x <- list在列表理解中的陳述很重要。如果你寫：

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

這相當於一個嵌套循環與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')]

（添加新行以便於驗證）

來源

2017-09-28 13:36:44

組織在Haskell的列表理解

回答

相關問題