/ / Haskell: Der erwartete Typ konnte nicht mit dem tatsächlichen Typ übereinstimmen - haskell

Haskell: Der erwartete Typ konnte dem tatsächlichen Typ nicht zugeordnet werden - haskell

Hey, ich habe Haskell in der Klasse gelernt und ich hatte das Problem, alle Instanzen von etwas aus einer Liste zu entfernen. Das ist mein Ziel, aber ich stoße auf diesen Fehler, dem ich nicht folgen kann.

--delete element from list
removeElement :: [a] -> [a]
removeElement x [] = []
removeElement x aList =
if (head aList) == x
then removeElement x (tail aList)
else aList

Der Fehler, den ich erhalte, ist folgender:

Couldn"t match expected type `[[a]] -> [[a]]"
with actual type `[a]"
Relevant bindings include
removeElement :: [a] -> [a] (bound at hwmk3.hs:8:1)
The equation(s) for `removeElement" have two arguments,
but its type `[a] -> [a]" has only one

Ich vermute, dass die Syntax falsch ist, aber ich bin mir nicht sicher, wie ich es beheben soll. Danke für Ihre Hilfe.

Antworten:

5 für die Antwort № 1

Ein paar Dinge:

Ihre Typ-Anmerkung weist auf Ihre Funktion hinSie erhalten einen einzelnen Listenparameter und geben eine Liste zurück, während die Implementierung angibt, dass Sie zwei Parameter erhalten sollen, von denen der erste ein einzelnes Element ist.

Außerdem, da du es verwendest == Um zu vergleichen, müssen Sie sicherstellen, dass Ihr Typ der ist Eq Typenklasse.

Ihre Typ-Annotation sollte wahrscheinlich so aussehen:

removeElement :: Eq a => a -> [a] -> [a]

Sie können auch Dinge vereinfachen, indem Sie die Mustererkennung nutzen. Sie müssen nicht verwenden head und tail wenn Sie Ihre Funktion so definieren:

removeElement x aList@(y:ys) =
if y == x
then removeElement x ys
else aList

jedochEs liegt ein logischer Fehler in der bedingten Anweisung vor. Da dies wie Hausaufgaben klingt, werde ich es dir überlassen, die Antwort zu finden. Tipp, versuch es removeElement 3 [1, 2, 3]


1 für die Antwort № 2

Wenn Sie die explizite Typdeklaration Ihrer Funktion weggelassen hätten, hätte Haskell etwas Ähnliches abgeleitet a -> [a] -> [a]. In der Tat, es immer noch Das erklärt, weshalb es sich beschwert, dass es nicht mit Ihrem angegebenen Typ übereinstimmt.

Das von Haskell berichtete Problem ist dies. Betrachten Sie Ihre zweite Gleichung, die zu entschlüsselt

removeElement x = aList -> if (head aList) == x then removeElement x (tail aList) else aList

ein paar Dinge sind "offensichtlich":

  1. x :: [a] als Argument zu removeElement.
  2. Der Lambda-Ausdruck hat einen Typ t -> v für einige Arten t und v.

Aber das haben wir schon gesagt removeElement :: [a] -> [a], also können wir uns Werte einfallen lassen t und v so dass [a] ~ t -> v? Könnte sein. Lassen Sie uns Schlussfolgertypen führen.

t ist die Art von aList, woraus wir schließen können head aList == x sein [[a]]. Den rekursiven Aufruf für den Moment überspringen, können wir auch sehen aList ist der Rückgabewert, also v ist auch [[a]]. So, t -> v ist wirklich [[a]] -> [[a]].

Können wir einen Wert vom Typ zuordnen? [[a]] -> [[a]] mit [a]?

Nein, deshalb erhalten Sie die genaue Fehlermeldung, die Sie tun.


0 für die Antwort № 3

Ihre Typ-Signatur sollte sein

removeElement :: a -> [a] -> [a]

Es sieht auch so aus, als ob deine Funktion nicht das tut, was du denkst.