Warum kann ich nicht hinzufügen, Integer zu Double in Haskell?

Warum ist es, dass ich tun kann:

1 + 2.0

aber wenn ich versuche:

let a = 1
let b = 2.0
a + b

<interactive>:1:5:
    Couldn't match expected type `Integer' with actual type `Double'
    In the second argument of `(+)', namely `b'
    In the expression: a + b
    In an equation for `it': it = a + b

Dieser scheint einfach nur komisch! Macht es überhaupt Reise, die Sie bis?

P. S.: ich weiß, dass "1" und "2.0" sind polymorphe Konstanten. Das ist nicht was mir sorgen macht. Was mich beunruhigt, ist, warum haskell hat eine, was im ersten Fall, aber anderen in der zweiten!

Wie das meme geht, "braucht mehr fromIntegral".
Erinnert mich irgendwie an x.f() vs g=x.f; g(); in Javascript. Es nervt, wenn Variablen brechen die substitution model Abstraktion.

InformationsquelleAutor Andriy Drozdyuk | 2011-11-24

haskell

8

Können Sie GHCI zu lernen, ein wenig mehr über diese. Verwenden Sie den Befehl :t um den Typ eines Ausdrucks.
```
Prelude> :t 1
1 :: Num a => a
```
So 1 ist eine Konstante, die sein kann ein beliebiger numerischer Typ ( Double , Integer usw.)
```
Prelude> let a = 1
Prelude> :t a
a :: Integer
```
So, in diesem Fall, Haskell inferred der konkrete Typ für a ist Integer. Ähnlich, wenn Sie schreiben let b = 2.0 dann Haskell folgert die Art Double. Mit let gemacht Haskell schließen, ein spezifischer Typ als (vielleicht) notwendig war, und das führt zu deinem problem. (Jemand mit mehr Erfahrung als ich, vielleicht als Kommentar, warum dies der Fall ist.) Da (+) Typ Num a => a -> a -> a, die zwei Argumente müssen den gleichen Typ aufweisen.

Beheben Sie das Problem mit der fromIntegral Funktion:
```
Prelude> :t fromIntegral
fromIntegral :: (Num b, Integral a) => a -> b
```
Diese Funktion wandelt integer-Typen in andere numerische Typen. Zum Beispiel:
```
Prelude> let a = 1
Prelude> let b = 2.0
Prelude> (fromIntegral a) + b
3.0
```
- monomorphism Einschränkung ist der Grund, warum let bewirkt, dass eine bestimmte Art gewählt werden. Sie können dies überschreiben, indem Sie eine Art Unterschrift, oder durch :set -XNoMonomorphismRestriction im GHCi (oder das entsprechende flag beim kompilieren).
- Gibt es noch die flag, wenn compliling? Ich dachte, dass der compiler nicht tun "säumigen"...
- Es funktioniert. GHCi nur etwas anders ausfallenden Regeln. Vor allem, GHCi ermöglicht eine größere Gruppe von Klasse-Einschränkungen vorgegeben werden, und es fügt () in die Liste der Standard-Typen.
- Die zentrale Frage ist nicht wirklich die verschiedenen ausfallenden Regeln zwar, aber eher, dass, wenn eine Datei zu kompilieren GHC gelten nur für die säumigen zu befriedigen, die monomorphism Einschränkung nach der Analyse die ganze - Datei. Aber wenn Sie die Anweisungen in GHCI, es hat voll bewerten Sie jede Aussage, wie es eingegeben. Also die monomorphism Beschränkung ist viel weniger lästig beim zusammenstellen der ganzen Dateien, die säumigen berücksichtigt die Art und Weise, in der Sie diese variable verwenden. In GHCI Sie sind in der Regel die Eingabe Aussagen wie let x = 3, und eine (monomorphe) - Typ muss ausgewählt werden, für x ohne Kontext.
InformationsquelleAutor Calvin
20

Die Typ-Signatur von (+) ist definiert als Num a => a -> a -> a, was bedeutet, dass es funktioniert auf jedem Mitglied der Num typeclass, aber beide Argumente müssen vom gleichen Typ sein.

Ist hier das problem mit GHCI und es stellt Typen, nicht von Haskell selbst. Wenn Sie entweder Ihre Beispiele in einer Datei (mit do für die let Ausdrücken), wäre es kompilieren und ausführen in Ordnung, da GHC würde die ganze Funktion als Rahmen, um zu bestimmen, die Typen der Literale 1 und 2.0.

All das geschieht im ersten Fall ist GHCI ist zu raten, die Arten der zahlen, die Sie eingeben. Die präziseste ist ein Double, so dass es gerade davon ausgegangen, der andere war angeblich ein Double und führt die Berechnung. Jedoch, wenn Sie die let Ausdruck, es hat nur eine Reihe von arbeiten, so entscheidet es 1 ist ein Integer und 2.0 ist ein Double.

EDIT: GHCI ist nicht wirklich "raten", es ist mit sehr spezifischen Typ säumigen Regeln, die definiert sind in der Haskell-Report. Sie können Lesen, ein wenig mehr über das hier.
- First off, die ich von Ihnen positiv bewertet werden. Aber wie ich haben die Angewohnheit, Erbsenzählerei: es wird Eine statische Typ-system unterstützt das hinzufügen von Nummern verschiedener Typen einwandfrei. Es ist nur so, dass die definition von Haskell-für erledigt ((+) :: Num a => a -> a -> a) nicht erlauben. (Es braucht nicht sehr gut zu spielen mit der Typ-Inferenz aber, das ist wahrscheinlich der Grund war es nicht getan.) Auch Ihre Antwort kann klarer werden, wenn Sie ausdrücklich ("erraten", ist nicht gerecht IMHO) erklären Typ ausfallenden und die Tatsache, dass Literale sind polymorph.
- "Haskell ein statisches Typsystem, so dass Sie nie in der Lage sein, zwei verschiedene Arten zusammen." Das ist eine ziemlich grobe Vereinfachung. Eine Menge von Sprachen, die über statische Systeme und ermöglichen das hinzufügen von ints in doubles. Das Schlüsselwort hier ist, dass Haskell hat keine impliziten Konvertierungen.
- Ja, ich habe nicht das Gefühl, ich hatte einen guten genug Griff Typ säumigen und wie es zu erklären. Fühlen Sie sich frei, um Ihre eigene Antwort mit dem Zeug.
- Sie haben Recht - aber Sie sind nicht die Beantwortung der Frage. Können Sie fügen Sie als erste Zeile Ihrer Antwort folgende: "Das problem ist, mit "ghci" - interpreter. Wenn Sie das gleiche schreiben (der "let" - natürlich) in eine Datei, und kompilieren Sie es - es funktionieren würde, ok." Und dann überlassen Sie den rest Ihrer Antwort, werde ich akzeptieren.
- Bearbeitet. Dies ist eine Art von chaotisch Antwort und die beiden anderen Antworten haben nützliche Dinge, die ich nicht wirklich erwähnen, so stellen Sie sicher, dass Sie Blick auf diese zu.
- Das ist so nicht ganz richtig. Die monomorphism Einschränkung wird auch in der compiler. Der Unterschied ist, dass beim kompilieren, alle Definitionen sind Typ-geprüft in einem gehen, so wäre es Standard a zu Double wegen der Art, wie man es verwendet. Allerdings, wenn Sie versuchen, verwenden Sie a einmal in einem Integer Kontext und einmal in einer Double Kontext, erhalten Sie das gleiche problem, weil ohne eine Art Signatur der compiler immer noch versuchen, zu folgern, eine monomorphe Art für a.
- Könnten Sie ein Beispiel-Skript-Datei, die müsste das gleiche problem dann?
- Wenn Sie schrieb etwas in eine Datei wie: a = 1; b = 2.0; useless = div a 3; add = a + b es nicht kompilieren, weil Sie eine in eine Integer Umfeld (mit div) und eine Double Zusammenhang mit add.
InformationsquelleAutor Jeff Burka
11

Das erste funktioniert, weil die numerischen Literale sind polymorph (Sie werden interpretiert als fromInteger literal resp. fromRational literal), also in 1 + 2.0 Sie wirklich haben fromInteger 1 + fromRational 2, in der Abwesenheit von anderen Einschränkungen, das Ergebnis geben standardmäßig Double.

Die zweite hat nicht funktionieren, weil der monomorphism Einschränkung. Wenn Sie etwas binden, ohne eine Art Unterschrift und mit einem einfachen Muster Bindung (name = expresion), wird die entity zugewiesen bekommt eine monomorphe Art. Für die wörtliche 1 haben wir eine Num Einschränkung, also nach der säumige Regeln, seine Art ist standardmäßig auf Integer in der Bindung let a = 1. Ebenso die Bruch-literal-Typ ist standardmäßig auf Double.

Wird es funktionieren, durch die Art und Weise, wenn Sie :set -XNoMonomorphismRestriction im ghci.

Den Grund für die monomorphism Einschränkung ist zur Vermeidung des Verlustes von teilen, wenn Sie sehen, ein Wert, der aussieht wie eine Konstante, die Sie nicht erwarten, dass es berechnet werden, mehr als einmal, aber wenn es eine polymorphe Art, es würde neu berechnet werden jedesmal, wenn es benutzt wird.

InformationsquelleAutor Daniel Fischer
3

Andere angesprochen haben, viele Aspekte dieser Frage ganz gut. Ich möchte sagen, ein Wort über die Hintergründe, warum + hat der Typ Signatur Num a => a -> a -> a.

Erstens, die Num typeclass hat keine Möglichkeit zu konvertieren artbitrary Instanz Num in ein anderes. Angenommen ich habe einen Datentyp für komplexe zahlen; Sie sind immer noch zahlen, aber Sie können wirklich nicht richtig konvertieren Sie Sie in nur ein Int.

Zweitens, welche Art Unterschrift würden Sie bevorzugen?
```
(+) :: (Num a, Num b) => a -> b -> a
(+) :: (Num a, Num b) => a -> b -> b
(+) :: (Num a, Num b, Num c) => a -> b -> c
```
Nachdem man die anderen Optionen, werden Sie erkennen, dass a -> a -> a ist die einfachste Wahl. Polymorphe Ergebnisse (wie im Dritten Vorschlag oben) sind cool, aber manchmal zu allgemein, um verwendet werden, bequem.

Drittens, Haskell ist nicht Blub. Die meisten aber wohl nicht alle, Entscheidungen zum design von Haskell nicht berücksichtigt werden, die den Konventionen und Erwartungen der beliebtesten Sprachen. Ich Häufig genießen Sie sagen, dass der erste Schritt zum lernen von Haskell ist, zu verlernen, alles, was Sie denken, Sie wissen über die Programmierung des ersten. Ich bin mir sicher, dass die meisten, wenn nicht alle, erfahrene Haskellers wurden ausgelöst durch die Num typeclass, und verschiedene andere Kuriositäten Haskell, weil die meisten haben gelernt, mehr "mainstream" Sprache erste. Aber seien Sie geduldig, werden Sie schließlich erreichen Haskell nirvana. 🙂

InformationsquelleAutor Dan Burton

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.