Organiser la séquence de tuple dans Haskell Liste compréhension

Question

Bonjour chère communauté,

Je suis en train d'organiser la séquence de tuple dans une compréhension Liste Haskell.

par exemple. Je suis la liste suivante Comprehension:

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

et obtenez:

[ (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').. 

Maintenant, je veux la séquence comme suit:

[ (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').. 

Cela signifie: D'abord un compromis entre la capitale lettres 'A' & 'B', puis un compromis entre les petites lettres 'a', 'b', 'c', à l'avant-dernier le compromis entre les valeurs booléennes True, False et finalement les chiffres.

Malheureusement, je n'ai absolument aucune idée de comment les réaliser et je veux savoir comment vous pouvez manipuler la séquence d'une liste avec le tuple [(a,b,c)].

Answer 1

Le ordre des instructions x <- list dans la compréhension de liste est important. Si vous écrivez:

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

cela équivaut à une imbriquée boucle avec y étant la boucle intérieure. Ainsi, un équivalent python avec des boucles serait:

for x in list1: 
    for y in list2: 
     expr 

et donc la boucle interne est entièrement épuisée avant de la boucle extérieure prend la valeur suivante.

Nous avons donc besoin de réorganiser les déclarations telles que nous le premier choix d, puis b, puis c et enfin a. Cela signifie donc que nous nous tournons:

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

(j'ai fait les listes plus courtes en notation)

dans:

-- [(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"] 

(le commentaire est seulement de visualiser la différence)

qui génère:

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')] 

(nouvelles lignes ajoutées pour faciliter la vérification)