Wie man den Wert einer Vielleicht in Haskell

[edit vom Autor, 6 Jahre später] Dies ist eine unnötig lange Antwort, und ich bin nicht sicher, warum es akzeptiert wurde. Verwenden maybe oder Data.Maybe.fromMaybe wie vorgeschlagen, in der höchsten von Ihnen positiv bewertet werden Antwort. Was folgt, ist eher ein Gedanken-experiment eher als praktische Ratschläge.

So, Sie versuchen, eine Funktion erstellen, die funktioniert für eine Reihe von verschiedenen Arten. Dies ist eine gute Zeit, um eine Klasse. Wenn Sie schon programmiert in Java oder C++ wird eine Klasse in Haskell ist eine Art, wie eine Schnittstelle in diesen Sprachen.

class Nothingish a where
    nada :: a

Diese Klasse definiert einen Wert nada, die soll Klasse sein äquivalent Nothing. Jetzt zum lustigen Teil: macht Instanzen dieser Klasse!

instance Nothingish (Maybe a) where
    nada = Nothing

Für einen Wert des Typs Maybe a, der Nichts-wie-Wert ist, gut, Nothing! Das wird ein komisches Beispiel, in einer minute. Aber bevor dann, machen wir Listen eine Instanz dieser Klasse zu.

instance Nothingish [a] where
    nada = []

Wird eine leere Liste ist eine Art, wie Nichts, richtig? Also für einen String (das ist eine Liste von Char), es wird ein leerer string zurückgegeben, "".

Zahlen sind auch eine einfache Implementierung. Sie haben bereits angedeutet, dass 0 offensichtlich stellt das "Nichts" für zahlen.

instance (Num a) => Nothingish a where
    nada = 0

Dieser wird tatsächlich nicht funktionieren, es sei denn, Sie setzen eine spezielle Zeile am Anfang der Datei

{ -# LANGUAGE FlexibleInstances, UndecidableInstances, OverlappingInstances #- }

Oder wenn Sie Sie kompilieren können Sie die flags für diese Sprache pragmas. Mach dir keine sorgen über Sie, Sie sind nur die Magie, die macht mehr Sachen, die funktionieren.

So, jetzt haben Sie diese Klasse und diese Instanzen...jetzt lasst uns einfach neu schreiben Sie Ihre Funktion, Sie zu benutzen!

eliminate :: (Nothingish a) => Maybe a -> a
eliminate (Just a) = a
eliminate Nothing  = nada

Bemerken, dass ich nur geändert 0 zu nada, und der rest ist die gleiche. Let ' s give it a spin!

ghci> eliminate (Just 2)
2
ghci> eliminate (Just "foo")
"foo"
ghci> eliminate (Just (Just 3))
Just 3
ghci> eliminate (Just Nothing)
Nothing
ghci> :t eliminate
eliminate :: (Nothingish t) => Maybe t -> t
ghci> eliminate Nothing
error! blah blah blah...**Ambiguous type variable**

Sieht Super, Werte und Sachen. Beachten Sie die (Einfach Nichts), verwandelt sich in Nichts, sehen Sie? Das war ein komisches Beispiel, ein Vielleicht in ein Vielleicht. Anyways...was eliminate Nothing? Gut, der entstehende Typ ist mehrdeutig. Er weiß nicht, was wir erwarten. So haben wir zu sagen, was wir wollen.

ghci> eliminate Nothing :: Int
0

Gehen Sie voran und versuchen Sie es heraus für andere Arten; sehen Sie es bekommt nada für jeden. So, jetzt, wenn Sie diese Funktion verwenden mit Ihrem combine - Funktion, erhalten Sie diese:

ghci> let combine a b c = (eliminate a, eliminate b, eliminate c)
ghci> combine (Just 2) (Just "foo") (Just (Just 3))
(2,"foo",Just 3)
ghci> combine (Just 2) Nothing (Just 4)
error! blah blah Ambiguous Type blah blah

Bemerken, die Sie noch haben, um anzuzeigen, welche Art Ihr "Nichts" ist, oder darauf hinweisen, was zurück geben, die Sie erwarten.

ghci> combine (Just 2) (Nothing :: Maybe Int) (Just 4)
(2,0,4)
ghci> combine (Just 2) Nothing (Just 4) :: (Int, Int, Int)
(2,0,4)

Oder Sie einschränken könnte die Typen, die Ihre Funktion erlaubt, indem es seine Art Signatur ausdrücklich in der Quelle. Dies macht Sinn, wenn die logische Verwendung der Funktion wäre, dass es nur mit den Parametern des gleichen Typs.

combine :: (Nothingish a) => Maybe a -> Maybe a -> Maybe a -> (a,a,a)
combine a b c = (eliminate a, eliminate b, eliminate c)

Nun es funktioniert nur, wenn alle drei Vielleicht Dinge, die sind vom gleichen Typ. Auf diese Weise wird es daraus schließen, dass die Nothing ist der gleiche Typ wie die anderen.

ghci> combine (Just 2) Nothing (Just 4)
(2,0,4)

Keine Zweideutigkeit, yay! Aber jetzt ist es ein Fehler, zu mischen und anzupassen, wie wir es zuvor getan haben.

ghci> combine (Just 2) (Just "foo") (Just (Just 3))
error! blah blah  Couldn't match expected type  blah blah
blah blah blah    against inferred type         blah blah

Gut, ich denke, dass war eine ausreichend lange und übertrieben Antwort. Genießen.

Ich bin neu in Haskell auch, also ich weiß nicht, ob diese vorhanden ist, in die Plattform aber (ich bin sicher, es tut), sondern wie über ein "erhalten oder sonst" - Funktion, um einen Wert, wenn es vorhanden ist, sonst Rückgabe eines default?

getOrElse::Maybe a -> a -> a
getOrElse (Just v) d = v
getOrElse Nothing d  = d

Den eliminate Funktion geben Sie die Signatur ist:

eliminate :: Maybe Int -> Int

Das ist, weil es gibt 0 zurück, auf Nichts, zwingt den compiler davon ausgehen, dass a :: Int in Ihrem eliminate Funktion. Damit der compiler leitet den Typ der Signatur der combine Funktion:

combine :: Maybe Int -> Maybe Int -> Maybe Int -> (Int, Int, Int)

... und das ist genau, warum es nicht funktioniert, wenn Sie eine Zeichenfolge übergeben, um es.

Wenn Sie schrieb es als:

combine a b c = (eliminate a, eliminate b, eliminate c)
                where eliminate (Just a) = a
                      eliminate Nothing = undefined

dann würde es gearbeitet haben, mit einer Schnur oder mit jedem anderen Typ. Der Grund dafür beruht auf der Tatsache, dass undefined :: a, die macht eliminate polymorphe und anwendbar auf andere Typen als Int.

Natürlich, das ist nicht das Ziel des Codes, d.h., um die combine-Funktion insgesamt.

In der Tat, selbst wenn eine Anwendung von combine einige Argumente Nichts gelingen würde (das ist, weil Haskell ist faul standardmäßig), sobald Sie versuchen, die Ergebnisse zu bewerten, Sie würde einen Laufzeitfehler erhalten, als undefined können nicht ausgewertet werden, um etwas sinnvolles (um es einfach auszudrücken).