itérer sur une liste en haskell

J'ai une liste de liste de caractères ::[[Char]].
J'ai besoin d'itérer à la fois sur la liste de chaînes de caractères et également au-dessus de chaque personnage dans chaque chaîne.

Dire, ma liste est présent dans cette variable.

let xs

S'il vous plaît suggérer un moyen facile pour effectuer une itération.

Nous pourrions donner des conseils plus spécifiques si vous avez également expliqué ce vous voulez faire tout en "itération".

OriginalL'auteur code4fun | 2012-01-26

haskell

15

Si vous souhaitez appliquer une fonction f à chaque élément d'une liste comme ceci:
```
[a, b, c, d] → [f a, f b, f c, f d]
```
puis map f xs fait le tour. map transforme une fonction sur les éléments d'une fonction sur les listes. Donc, nous pouvons en nid d'opérer sur les listes de listes: si f transforme as en bs, map (map f) transforme [[a]]s en [[b]]s.

Si vous voulez faire quelque IO action pour chaque élément d'une liste (qui est plus classique, itération), alors vous êtes probablement à la recherche pour forM_:¹
```
forM_ :: [a] -> (a -> IO b) -> IO ()
```
Vous donner une fonction, et il l'appelle avec chaque élément de la liste dans l'ordre. Par exemple, forM_ xs putStrLn est un IO action qui affiche chaque chaîne dans xs sur sa propre ligne. Voici un exemple plus impliqué l'utilisation de forM_:
```
main = do
  ...
  forM_ xs $ \s -> do
    putStrLn "Here's a string:"
    forM_ s print
    putStrLn "Now it's done."
```
Si xs contient ["hello", "world"], alors ce sera l'impression: l'impression
```
Here's a string:
'h'
'e'
'l'
'l'
'o'
Now it's done.
Here's a string:
'w'
'o'
'r'
'l'
'd'
Now it's done.
```
¹ forM_ a effectivement un type plus général, mais la version plus simple que j'ai montré est plus pertinent ici.

salut merci pour la réponse.en fait, je veux profiter de chaque élément de la liste et de les appliquer si-sinon consdition.je tiens donc à chaque élément un par un dans "laissez-élément" comme pour la boucle ne
J'ai mis à jour ma réponse à montrer comment parcourir une liste d'effectuer IO tout en donnant un nom à chaque élément.
merci pour l'aide
Je fais IO, votre réponse semble aider beaucoup, mais je reçois un Not in scope: ‘forM_’. Une idée?
Il a réglé avec import Data.Foldable. Comment se fait - forM_ prend la liste comme premier argument alors que find, map et tous les autres de le faire dans l'autre sens?

OriginalL'auteur ehird
3

La "bonne" façon d'itérer est en fait fois. Tout ce que vous pourriez jamais vouloir le faire avec une liste qui peut être fait avec un pli. Considérons ce que vous voulez faire. Vous pensez probablement à quelque chose comme ceci:
```
for (row in xs):
  for (c in row):
    doSomething
```
Le problème est, vous êtes probablement faire usage de variables mutables dans doSomething. C'est ok, on peut le gérer. Supposons donc que vous avez.
```
def iter2d(xs):
  outerVar = outerInit
  for (row in xs):
    innerVar = innerInit(row)
    outerVar.adjust1(row)
    for (c in row):
      innerVar.adjust2(c)
      outerVar.adjust3(c, innerVar)
  return outerVar
```
Nous allons traduire que des plis. Et l'immuabilité.
```
iter2d :: [[Char]] -> Something
iter2d xs = foldl' outerStep outerInit xs
  where outerInit = ... -- same as outerInit above
        outerStep acc row = fst $ foldl' innerStep innerInit' row)
          where innerInit' = ((adjust1 acc row), innerInit row)
        innerInit row = ... -- same as innerInit above
        innerStep (outAcc, inAcc) c = (outAcc', inAcc')
          where inAcc' = adjust2 inAcc c
                outAcc' = adjust3 outAcc c inAcc'
```
Avis avec l'immutabilité, nous sommes contraints d'indiquer que outAc' dépend inAcc', plutôt que de inAcc, de sens, de "l'état" de innerVar après il est mis à jour.

Maintenant, vous pourriez dire "wow c'Haskell ressemble de manière moche, pourquoi aurais-je besoin pour utiliser Haskell". Oui, il fait moche, mais seulement parce que j'ai adaptée à une traduction directe de code impératif. Une fois que vous vous habituez à l'aide de plis au lieu de "itérer sur une liste", puis vous verrez que le pliage est une technique très puissante qui vous permet de faire beaucoup de choses de manière plus élégante que pour les boucles permettent.

Remarque: map est une spécialisation de fold.

OriginalL'auteur Dan Burton
3
```
map (map f) l
```
où f :: Char -> Foo est une fonction à appliquer à chaque Char et l :: [[Char]]

retourne l' :: [[Foo]]

OriginalL'auteur Dan D.
2

Juste que:
```
[c | x <- xs, c <- x]
```
OriginalL'auteur Laurent

Vous devez vous connecter pour publier un commentaire.