Gibt es eine Haskell-Sprache, um mehrere Funktionen auszuprobieren und zu stoppen, sobald eine erfolgreich ist?

In Haskell kann ich den Typ verwenden a -> Maybe b, um eine Funktion zu modellieren, die entweder einen Wert vom Typ bzurückgibt oder nichts zurückgibt (dies schlägt fehl).

Wenn ich Typen a1, ..., a(n+1)und Funktionen f1, ..., fn, mit fi :: ai -> Maybe a(i+1)für alle i, 1 <= i <= nkann ich die Kette , die Funktionen durch die Verwendung des >>=Betreibers der MaybeMonade und schreiben:

f1 x >>= f2 >>= f3 >>=... >>= fn

Der >>=Operator stellt sicher, dass jede Funktion angewendet wird, solange der Vorgänger einen aussagekräftigen Wert zurückgegeben hat. Sobald eine Funktion in der Kette ausfällt, fällt die gesamte Kette aus (kehrt zurück Nothing) und weitere Funktionen in der Kette werden nicht ausgewertet.

Ich habe ein etwas ähnliches Muster, bei dem ich mehrere Funktionen am selben Eingang ausprobieren und zurückkehren möchte, sobald eine Funktion erfolgreich ist . Wenn alle Funktionen fehlschlagen (return Nothing), sollte die gesamte Berechnung fehlschlagen. Genauer gesagt habe ich Funktionen f1, ..., fn :: a -> Maybe bund definiere die Funktion

tryFunctions :: [a -> Maybe b] -> a -> Maybe b
tryFunctions []       _ = Nothing
tryFunctions (f : fs) x = case f x of
                            Nothing    -> tryFunctions fs x
                            r@(Just _) -> r

In gewissem Sinne ist dies für die MaybeMonade insofern dual , als eine Berechnung beim ersten Erfolg statt beim ersten Misserfolg stoppt.

Natürlich kann ich die oben beschriebene Funktion verwenden, aber ich habe mich gefragt, ob es eine bessere, gut etablierte und idiomatische Möglichkeit gibt, dieses Muster in Haskell auszudrücken.

Bei einer geschlossenen Menge (feste Anzahl von Elementen) Smit Elementen {a..z}und einem binären Operator *:

Es gibt ein einziges Identitätselement, iso dass:

forall x in S: i * x = x = x * i

Der Operator ist assoziativ, so dass:

forall a, b, c in S: a * (b * c) = (a * b) * c

Du hast ein Monoid.

Wenn Sie nun ein beliebiges Monoid haben, können Sie eine Binärfunktion fwie folgt definieren :

f(i, x) = x
f(x, _) = x

Dies bedeutet, dass für das Beispiel des MaybeMonoids ( Nothingist das oben als bezeichnet bezeichnete Identitätselement i):

f(Nothing, Just 5) = Just 5
f(Just 5, Nothing) = Just 5
f(Just 5, Just 10) = Just 5
f(Nothing, f(Nothing, Just 5)) = Just 5
f(Nothing, f(Just 5, Nothing)) = Just 5

Überraschenderweise kann ich diese genaue Funktion in den Standardbibliotheken nicht finden, was wahrscheinlich auf meine eigene Unerfahrenheit zurückzuführen ist. Wenn jemand anderes dies freiwillig tun kann, würde ich es aufrichtig schätzen.

Hier ist die Implementierung, die ich aus dem obigen Beispiel abgeleitet habe:

(<||>) :: (Monoid a, Eq a) => a -> a -> a
x <||> y
     | x == mempty = y
     | True = x

Beispiel:

λ> [] <||> [1,2] <||> [3,4]
[1,2]
λ> Just "foo" <||> Nothing <||> Just "bar"
Just "foo"
λ> Nothing <||> Just "foo" <||> Just "bar"
Just "foo"
λ> 

Dann, wenn Sie eine Liste von Funktionen als Eingabe verwenden möchten ...

tryFunctions x funcs = foldl1 (<||>) $ map ($ x) funcs

Beispiel:

instance Monoid Bool where
         mempty = False
         mconcat = or
         mappend = (||)

λ> tryFunctions 8 [odd, even]
True
λ> tryFunctions 8 [odd, odd]
False
λ> tryFunctions 8 [odd, odd, even]
True
λ> 

import Data.Monoid

tryFunctions :: a -> [a -> Maybe b] -> Maybe b
tryFunctions x = getFirst . mconcat . map (First . ($ x))

Das klingt sehr danach , Fehler durch eine Liste von Erfolgen zu ersetzen

Sie sprechen Maybe aeher über als [a], aber in der Tat sind sie sich sehr ähnlich: Wir können uns vorstellen, dass es Maybe aso ist [a], außer dass es höchstens ein Element enthalten kann (dh Nothing ~= []und Just x ~= [x]).

Bei Listen tryFunctionswäre dies sehr einfach: Wenden Sie alle Funktionen auf das angegebene Argument an und verketten Sie dann alle Ergebnisse miteinander. concatMapwird das schön machen:

tryFunctions :: [a -> [b]] -> a -> [b]
tryFunctions fs x = concatMap ($ x) fs

Auf diese Weise können wir sehen, dass der <|>Operator für Maybewie eine Verkettung für 'Listen mit höchstens einem Element' wirkt.

Teilen Sie es im Geiste von Conal in kleinere, einfachere Operationen auf.

In diesem Fall asumaus Data.Foldablemacht den Hauptteil.

tryFunction fs x = asum (map ($ x) fs)

Alternativ können Sie die MonoidInstanz von a la Jimmy Hoffa für verwenden, (->)aber dann benötigen Sie eine MonoidInstanz für Maybeund die Standardinstanz macht nicht das, was Sie wollen. Du willst Firstvon Data.Monoid.

tryFunction = fmap getFirst . fold . map (fmap First)

(Oder mconcatfür eine ältere, spezialisiertere Version von fold.)