Löschen Sie alle Instanzen aus der Liste

Question

Ich versuche, alle Instanzen eines Elements in einer Liste mit Haskell zu löschen. Ich bekomme einen Fehler, den ich nicht wirklich verstehe. Kann mir jemand helfen und mich wissen lassen, ob ich das Richtige tue?

deleteAllInstances :: (a, [l]) => a -> [l] -> [l] 
deleteAllInstances (a, []) = [] 
deleteAllInstances (i, (x:xs)) 
    | i == x = tail 
    | otherwise = x ++ tail 
    where tail = deleteAllInstances i xs 

Answer 1

Zunächst ist die Art Signatur fehlerhaft.

deleteAllInstances :: (a, [l]) => a -> [l] -> [l] 

Eine Art Unterschrift hat die Form

name :: (Constraints) => type 

wo Constraints Typklassen beinhalten, wie (Ord a, Show a). In diesem Fall verwendet die Funktion (==), daher muss eine Einschränkung der Form vorliegen.

Dann stimmt die Funktionsdefinition nicht mit dem Typ Teil überein, Sie haben sie definiert, um ein Paar als Argument zu verwenden, während die Typ-Signatur das Gegenteil sagt (Ihre Definition ist nicht Curritiert, der Typ ist curried).

deleteAllInstances (a, []) = [] 
deleteAllInstances (i, (x:xs)) 
    | i == x = tail 
    | otherwise = x ++ tail 
    where tail = deleteAllInstances i xs 

dann verwenden Sie (++) ein Element der Vorderseite einer Liste zu kleben, aber (++) verkettet zwei Listen, müssen Sie (:) hier.

Der einfachste Weg, um die Funktion definieren würde filter

deleteAllInstances :: Eq a => a -> [a] -> [a] 
deleteAllInstances a xs = filter (/= a) xs 

aber wenn man sich die explizite Rekursion tun wollen benutzen,

deleteAllInstances :: Eq a => a -> [a] -> [a] 
deleteAllInstances a (x:xs) 
    | a == x = rest 
    | otherwise = x : rest 
     where 
     rest = deleteAllInstances a xs 
deleteAllInstances _ _ = [] 

Answer 2

Ich bin mir nicht sicher, was Sie mit den (a, [l]) vor den => zu tun versuchen, aber ich glaube es nicht für notwendig. Syntax dort ist normalerweise reserviert für die Angabe, welche Art a und l erfüllen sollte.

Auch Ihre Funktion benötigt zwei Argumente, a und [l], wie Sie später in der Funktionsdefinition angegeben haben. Ihre Implementierung der Funktion benötigt jedoch nur ein Argument, ein Tupel. Wie ich bereits erwähnt habe, dient das Tupel nur dazu, zu spezifizieren, welche Typen die Argumente sein sollen, und es kann kein Muster dafür gefunden werden.

deleteAllInstances :: a -> [l] -> [l] 
deleteAllInstances a [] = [] 
deleteAllInstances i (x:xs) 
    | i == x = rest 
    | otherwise = x : rest 
    where rest = deleteAllInstances i xs 

Wenn Sie es mit filter schreiben wollte, können Sie immer den folgenden Code verwenden

deleteAllInstances :: a -> [a] -> [a] 
deleteAllInstances a = filter (/=a) 

Answer 3

ich eine sehr tatsächlich Liste Verständnis finden intuitive Notation für Probleme wie diese:

deleteAllInstances :: Eq a => a -> [a] -> [a] 
deleteAllInstances a list = [x | x <- list, x /= a]