Haskell: Wie ist <*> ausgesprochen?

Sorry, ich weiß wirklich nicht, mein Mathe, also ich bin mal gespannt, wie sich auszusprechen, um die Funktionen in der Applicative typeclass

Wissen, Ihre mathematischen, oder nicht, ist weitgehend irrelevant ist hier, glaube ich. Wie Sie wahrscheinlich wissen, Haskell, leiht sich ein paar bits von Terminologie aus verschiedenen Bereichen der abstrakten Mathematik, insbesondere Kategorie Theorie, von Woher erhalten wir funktoren und Monaden. Die Verwendung dieser Begriffe in Haskell unterscheidet sich etwas von der formalen mathematischen Definitionen, aber Sie sind in der Regel nahe genug, um gut zu sein, beschreibende Begriffe jedenfalls.

Den Applicative Typ der Klasse sitzt irgendwo zwischen Functor und Monad, so würde man erwarten, dass es eine ähnliche mathematische Grundlage. Die Dokumentation für die Control.Applicative Modul beginnt mit:

Dieses Modul beschreibt eine Struktur Zwischenschritt zwischen dem Funktor und Monade: es bietet pure Ausdrücke und Sequenzierung, aber nicht verbindlich. (Technisch gesehen, einen starken lax monoidale Funktor.)

Hmm.

class (Functor f) => StrongLaxMonoidalFunctor f where
    . . .

Nicht ganz so eingängig wie Monad, denke ich.

Was das alles im Grunde läuft darauf hinaus, dass Applicative entspricht nicht irgendein Konzept, dass besonders interessante mathematisch, also es gibt keine fertigen Begriffe herumliegen, die Art einzufangen, wie es s verwendet in Haskell. Also, legen Sie die Mathematik beiseite für jetzt.

---

Wollen wir wissen, was zu nennen (<*>) könnte es helfen, zu wissen, was es im Grunde bedeutet.

Also, was ist Los mit Applicative, sowieso, und warum tun wir es so nennen?

Was Applicative beträgt in der Praxis ist ein Weg zu heben beliebigen Funktionen in einem Functor. Betrachten Sie die Kombination von Maybe (wohl die einfachste nicht-triviale Functor) und Bool (ebenso ist die einfachste nicht-triviale Daten-Typ).

maybeNot :: Maybe Bool -> Maybe Bool
maybeNot = fmap not

Die Funktion fmap können uns heben not von der Arbeit auf Bool zu arbeiten Maybe Bool. Aber was ist, wenn wir wollen, zu heben (&&)?

maybeAnd' :: Maybe Bool -> Maybe (Bool -> Bool)
maybeAnd' = fmap (&&)

Gut, das ist nicht das, was wir wollen an alle! In der Tat, es ist ziemlich nutzlos. Wir können versuchen, schlau zu sein und schleichen sich andere Bool in Maybe durch die Hintertür...

maybeAnd'' :: Maybe Bool -> Bool -> Maybe Bool
maybeAnd'' x y = fmap ($ y) (fmap (&&) x)

...aber das ist nicht gut. Für eine Sache, es ist falsch. Für anderen Sache, es ist hässlich. Wir könnten es weiter versuchen, aber es stellt sich heraus, dass es kein Weg zu heben eine Funktion mehrere Argumente mit der Arbeit an einer beliebigen Functor. Ärgerlich!

Auf der anderen Seite, wir könnten es einfach tun, wenn wir Maybe's Monad Beispiel:

maybeAnd :: Maybe Bool -> Maybe Bool -> Maybe Bool
maybeAnd x y = do x' <- x
                  y' <- y
                  return (x' && y')

Nun, das ist eine Menge Aufwand nur um zu übersetzen, die eine einfache Funktion-das ist, warum Control.Monad bietet eine Funktion, um es automatisch zu tun, liftM2. Die 2 in der name bezieht sich auf die Tatsache, dass es funktioniert auf die Funktion von genau zwei Argumente; ähnliche Funktionen gibt es für 3, 4 und 5 argument-Funktionen. Diese Funktionen sind besser, aber nicht perfekt, und die Angabe der Anzahl der Argumente ist hässlich und unbeholfen.

Das bringt uns zu der Papier eingeführt wurde Applicative class-Typ. In es, machen die Autoren im wesentlichen zwei Beobachtungen:

• Lifting-multi-argument-Funktionen in einem Functor ist eine sehr Natürliche Sache zu tun
• Dabei nicht erforderlich, die volle Funktionalität einer Monad

Normale Funktion der Anwendung ist schriftlich durch einfache Nebeneinanderstellung der Begriffe, also um "gehoben Anwendung" so einfach und natürlich wie möglich, das Papier führt infix-Operatoren stehen für die Anwendung, hob in der Functor, und einer Typ-Klasse zu bieten, was gebraucht wird.

All dies bringt uns zu dem folgenden Punkt: (<*>) einfach darstellt, Funktion, Anwendung-warum also sprechen es anders ab, als Sie den Leerraum "nebeneinander-operator"?

Aber wenn das nicht sehr befriedigend ist, können wir beobachten, dass die Control.Monad Modul bietet auch eine Funktion, die tut die gleiche Sache für Monaden:

ap :: (Monad m) => m (a -> b) -> m a -> m b

Wo ap ist, natürlich, kurz für "anwenden". Da jede Monad werden kann Applicative, und ap muss nur die Teilmenge der Funktionen in der letzteren können wir vielleicht sagen, dass wenn (<*>) nicht ein Betreiber, es sollte aufgerufen werden ap.

---

Können wir auch Dinge Herangehen von der anderen Richtung. Die Functor lifting-operation aufgerufen wird fmap weil es eine Verallgemeinerung der map operation auf Listen. Welche Art von Funktion, die auf Listen arbeiten würde, wie (<*>)? Gibt ' s was ap auf Listen, natürlich, aber das ist nicht besonders nützlich auf seine eigene.

In der Tat, es gibt vielleicht noch mehr Natürliche Deutung für Listen. Was kommt in den Sinn, wenn Sie sich in den folgenden geben Sie die Signatur?

listApply :: [a -> b] -> [a] -> [b]

Es gibt etwas, nur so verlockend die Idee von Futter die Listen parallel, die Anwendung jeder Funktion die erste, um das entsprechende element der zweiten. Leider für unseren alten Freund Monad diese einfache Bedienung gegen die Monaden-Gesetze, wenn die Listen sind unterschiedlich lang. Aber es macht einen feinen Applicative, in dem Fall (<*>) wird zu einem Aneinanderreihung einer verallgemeinerten version von zipWith, so können wir uns vielleicht vorstellen, nannte es fzipWith?

---

Diese zippen Idee eigentlich bringt uns der Kreis. Daran erinnern, dass Mathe Zeug früher über monoidale funktoren? Wie der name schon sagt, sind eine Art Kombination der Struktur eines monoiden und funktoren, die beide vertraut sind Haskell-Typklassen:

class Functor f where
    fmap :: (a -> b) -> f a -> f b

class Monoid a where
    mempty :: a
    mappend :: a -> a -> a

Was würden diese Aussehen, wenn Sie setzen Sie Sie in einer box zusammen und schüttelte es ein wenig? Von Functor wir halten die Idee einer Struktur unabhängig von dessen Typ-parameter, und von Monoid wir sorgen dafür, dass die Allgemeine form der Funktionen:

class (Functor f) => MonoidalFunctor f where
    mfEmpty :: f ?
    mfAppend :: f ? -> f ? -> f ?

Wir wollen nicht davon ausgehen, dass es ein Weg, um eine wirklich "leer" Functor, und wir können nicht zaubern einen Wert eines beliebigen Typs, so dass wir beheben die Art der mfEmpty als f ().

Wir auch nicht wollen, zwingen mfAppend zu müssen, um ein konsistentes Typ-parameter, also müssen wir jetzt diese:

class (Functor f) => MonoidalFunctor f where
    mfEmpty :: f ()
    mfAppend :: f a -> f b -> f ?

Was ist das Ergebnis geben Sie für mfAppend? Wir haben zwei beliebigen Typen, die wir nichts wissen, so haben wir nicht viele Optionen. Das vernünftigste ist, einfach beide behalten:

class (Functor f) => MonoidalFunctor f where
    mfEmpty :: f ()
    mfAppend :: f a -> f b -> f (a, b)

An welcher Stelle mfAppend ist nun deutlich eine generalisierte version von zip auf Listen, und wir können rekonstruieren Applicative einfach:

mfPure x = fmap (\() -> x) mfEmpty
mfApply f x = fmap (\(f, x) -> f x) (mfAppend f x)

Dies zeigt uns auch, dass pure ist in Bezug auf die Identität element einer Monoid, so dass andere gute Namen für Sie es könnte alles sein, was ein Gerät Wert ist, eine null-operation, oder so.

---

War langwierig, um es zusammenzufassen:

• (<*>) ist nur eine modifizierte Funktion-Anwendung, so können Sie entweder Lesen wie "ap" oder "übernehmen", oder zu umgehen, aber es ganz so, als würden Sie die normale Funktion der Anwendung.
• (<*>) auch grob verallgemeinert zipWith auf Listen, so kann man es Lesen als "zip-funktoren mit", ähnlich wie zu Lesen fmap als "Karte einen Funktor mit".

Die erste ist näher an der Absicht des Applicative Typ-Klasse-wie der name vermuten lässt--so das ist, was ich empfehlen.

In der Tat, ich ermutige liberale verwenden, und nicht die Aussprache, der alle gehoben Anwendung von Operatoren:

• (<$>), das hebt ein single-argument-Funktion in einem Functor
• (<*>), die Ketten ein multi-argument-Funktion durch eine Applicative
• (=<<), die bindet, eine Funktion, die in eine Monad auf eine bestehende Berechnung

Alle drei sind im Kern ganz normale Funktion, Anwendung, gewürzt ein bisschen.

InformationsquelleAutor C. A. McCann

In Kürze:

• <*> Sie können es nennen, gelten. So Maybe f <*> Maybe a ausgeprägt sein kann, als gelten Maybe f über Maybe a.

• Könnte man umbenennen pure zu of, wie viele JavaScript-Bibliotheken tun. In JS erstellen Sie eine Maybe mit Maybe.of(a).

Auch, Haskell-wiki hat eine Seite, die auf die Aussprache der Sprache Operatoren hier

InformationsquelleAutor Marcelo Lazaroni