Hilfe dieses Codes in Haskell

Question

Der folgende Code bei der Lösung dosn't kompilieren:

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] 

ich eine der folgenden Fehlermeldungen erhalten:

a) 
parse error on input `[' 

b) 
parse error on input `]' 

Ich habe versucht, infront einige während Räume einfügen oder Rückseite der letzten Zeile, aber es funktioniert nicht. Es macht mich mehr verärgert, weil ich nicht wirklich weiß, was passiert.

Benötigen

UPDATE helfen, eine Funktion und eine Liste als Argumente

reindex nimmt. Es nimmt die Indizes der Liste nacheinander und wendet die Funktion darauf an, um neue Indizes zu erzeugen. Es wird die neu generierten Indizes verwenden, um die Werte aus der ursprünglichen Liste abzurufen, um eine neue Liste zu bilden. Wenn ein neuer Index außerhalb der Grenzen der ursprünglichen Liste liegt, wird diese Nummer ignoriert.

Beispiele:

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

Answer 1

Ihre Funktion ist wirklich seltsam.

1. Die naheliegendste: Sie verpassen die in am Ende let. Verwenden Sie stattdessen where.
2. Ihre Typ-Signatur ist seltsam. Prüfen Sie!
3. Verwenden Sie Mustervergleich statt in der Definition von z.
4. y kann nicht gleichzeitig eine Nummer und eine Liste sein.

Es kann wie folgt aussehen:

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

Aber wie auch immer, ich verstehe nicht wirklich den Code. Wenn Sie erklären, was es tun soll, finden wir vielleicht eine einfachere Lösung dafür.

Edit:

Ich würde tun, was Sie so wollen: (Wenn andere Module sind erlaubt).

import Data.List 
import Data.Function 

reindex f list = map snd $ sortBy (compare `on` fst) newList where 
    l = length list 
    newIndizes = map f [0..] 
    inList (x,_) = x >= 0 && x < l 
    newList = filter inList $ zip newIndizes list 

Ich denke, es ist sowohl leichter zu verstehen und schneller (aber bitte Profil).

Das Verhalten ist nicht definiert, wenn die Funktion einen Wert zweimal auflisten kann. Sie können hinzufügen, das es zu beheben:

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

Und dies ist Ihre Art-Signatur:

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

Answer 2

Ihre zweite Zeile sieht seltsam aus. Ihre Funktion sollte eine Funktion von a bis a erwarten und eine Liste von a zurückgeben, aber dann ist das Muster in Ihrer zweiten Zeile nur eine Liste. Das ergibt für mich keinen Sinn.