Zusammenstellung zweier fehlerauslösender Funktionen in Haskell

Question

Das Problem, das mir gestellt wurde, lautet wie folgt:

Ähnlich wie bei mapMaybe definieren Sie die Funktion: composeMaybe :: (a->Maybe b) -> (b -> Maybe c) -> (a-> Maybe c) die zwei fehlerauslösende Funktionen zusammensetzt.

Der Typ Maybe a und die Funktion mapMaybe sind wie folgt kodiert:

data Maybe a = Nothing | Just a

mapMaybe g Nothing = Nothing
mapMaybe g (Just x) = Just (g x)

Ich habe versucht, eine Komposition wie diese zu verwenden:

composeMaybe f g = f.g

Aber es lässt sich nicht kompilieren.

Kann mir jemand die richtige Richtung weisen?

Answer 1

Das Werkzeug, das Sie suchen, existiert bereits. Es gibt zwei Kleisli-Kompositionsoperatoren in Control.Monad.

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

Wenn m = Maybe, wird die Implementierung von composeMaybe deutlich:

composeMaybe = (>=>)

Ein Blick auf die Definition von (>=>) ,

f >=> g     = \x -> f x >>= g

die Sie einbinden können, wenn Sie sie mit Ihren eigenen Worten als

composeMaybe f g x = f x >>= g

oder die man in do -Zucker als:

composeMaybe f g x = do 
    y <- f x
    g y

Im Allgemeinen würde ich einfach bei der Verwendung von (>=>) die aus guten theoretischen Gründen existiert, weil sie den saubersten Weg bietet, die Monadengesetze anzugeben.

Answer 2

Zunächst einmal: Wenn überhaupt, dann sollte es g.f , nicht f.g denn Sie wollen eine Funktion, die das gleiche Argument wie f annimmt und den gleichen Rückgabewert wie g liefert. Das funktioniert jedoch nicht, weil der Rückgabetyp von f nicht dem Argumenttyp von g entspricht (der Rückgabetyp von f hat ein Maybe in sich und der Argumenttyp von g nicht).

Was Sie also tun müssen, ist: Definieren Sie eine Funktion, die eine Maybe b als Argument. Wenn dieses Argument Nothing sollte er Folgendes zurückgeben Nothing . Wenn das Argument Just b sollte es zurückgeben g b . composeMaybe sollte die Zusammensetzung der Funktion mit f zurückgeben.

Answer 3

Hier ist eine ausgezeichnete Lehrgang über Haskell-Monaden (und insbesondere die Vielleicht Monade , die in den ersten Beispielen verwendet wird).

Answer 4

composeMaybe :: (a -> Maybe b)
             -> (b -> Maybe c)
             -> (a -> Maybe c)
composeMaybe f g = \x ->

Desde g nimmt ein Argument vom Typ b aber f erzeugt einen Wert vom Typ Maybe b müssen Sie einen Mustervergleich für das Ergebnis von f x wenn Sie das Ergebnis an g .

                         case f x of
                              Nothing -> ...
                              Just y  -> ...

Answer 5

Eine sehr ähnliche Funktion existiert bereits - der monadische Bindungsoperator, >>= . Sein Typ (für die Maybe-Monade) ist Maybe a -> (a -> Maybe b) -> Maybe b und wird folgendermaßen verwendet:

Just 100 >>= \n -> Just (show n) -- gives Just "100"

Es ist nicht genau dasselbe wie Ihr composeMaybe Funktion, deren erstes Argument eine Funktion ist, die einen Maybe-Wert anstelle eines direkten Maybe-Wertes zurückgibt. Aber Sie können Ihre composeMaybe Funktion sehr einfach mit diesem Operator - es ist fast so einfach wie die Definition der normalen Compose-Funktion, (.) f g x = f (g x) .