Aide dans la résolution de ce code dans Haskell

Question

Le code suivant dosn't compilez:

reindex :: (a -> a) -> [a] 
reindex [] = [] 
reindex f y = let x = (zip [0..] y) 
        z = [(f m) |el <- x, let m = fst el] 
       [n !! y | n <- z, (n !! y) > -1] 

je reçois une des erreurs suivantes:

a) 
parse error on input `[' 

b) 
parse error on input `]' 

J'ai essayé d'insérer quelques-uns tandis que les espaces ou Infront retour de la dernière ligne mais ça ne marche pas. Cela me rend plus contrarié parce que je ne sais pas vraiment ce qui se passe.

Besoin d'aide

MISE À JOUR

réindexation prend une fonction et une liste d'arguments. Il prend les index de la liste un par un et lui applique la fonction pour générer un nouvel index. Il utilisera les nouveaux index générés pour extraire les valeurs de la liste d'origine pour former une nouvelle liste. Si un nouvel index est en dehors des limites de la liste d'origine, ce numéro est ignoré.

exemples:

Main> reindex (\x -> x + 1) [3,4,5] 
[4,5] 
Main> reindex (\x -> x - 2) [3,4,5] 
[3] 

Answer 1

Votre fonction est vraiment étrange.

1. La plus évidente: vous manque le in à la fin de let. Utilisez where à la place.
2. Votre signature de type est étrange. Vérifie ça!
3. Utilisez la correspondance de modèle au lieu de laisser entrer la définition de z.
4. y ne peut pas être à la fois un nombre et une liste.

Il peut ressembler à ceci:

reindex _ [] = [] 
reindex f y = [n !! y | n <- z, (n !! y) > -1] where 
    x = (zip [0..] y) 
    z = [(f m) |(m,_) <- x] 

Mais de toute façon, je ne comprends pas vraiment le code. Si vous expliquez, ce qu'il devrait faire, nous pourrions trouver une solution plus facile pour cela.

Edit:

Je ferais ce que vous voulez comme ceci: (Si d'autres modules sont autorisés). Je pense que c'est à la fois plus facile à comprendre et plus rapide (mais s'il vous plaît profil).

Le comportement n'est pas défini si la fonction peut lister une valeur deux fois. Vous pouvez ajouter ceci à fixer:

reindex f list = map snd $ sortBy (compare `on` fst) cleanedList where 
    cleanedList = nubBy ((==) `on` fst) newList 

Et ceci est votre type signature:

reindex :: (Int -> Int) -> [a] -> [a] 

Answer 2

Votre deuxième ligne semble étrange. Votre fonction devrait attendre une fonction de a à et retourner une liste de a, mais alors le motif dans votre deuxième ligne est juste une liste. Cela n'a aucun sens pour moi.