Kann jemand die Verfahrfunktion in Haskell erklären?

Ich versuche und schaffe es nicht, die traverseFunktion zu nutzen Data.Traversable. Ich kann den Punkt nicht erkennen. Kann mir jemand bitte einen imperativen Hintergrund erklären, da ich einen imperativen Hintergrund habe? Pseudocode wäre sehr dankbar. Vielen Dank.

traverseist dasselbe wie fmap, außer dass Sie damit auch Effekte ausführen können, während Sie die Datenstruktur neu erstellen.

Schauen Sie sich das Beispiel aus der Data.TraversableDokumentation an.

 data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

Die FunctorInstanz von Treewäre:

instance Functor Tree where
  fmap f Empty        = Empty
  fmap f (Leaf x)     = Leaf (f x)
  fmap f (Node l k r) = Node (fmap f l) (f k) (fmap f r)

Es wird der gesamte Baum neu erstellt und fauf jeden Wert angewendet.

instance Traversable Tree where
    traverse f Empty        = pure Empty
    traverse f (Leaf x)     = Leaf <$> f x
    traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

Die TraversableInstanz ist fast dieselbe, außer dass die Konstruktoren im anwendungsbezogenen Stil aufgerufen werden. Dies bedeutet, dass wir beim Wiederaufbau des Baums (Nebenwirkungen) haben können. Die Anwendung ist fast die gleiche wie bei Monaden, außer dass die Auswirkungen nicht von früheren Ergebnissen abhängen können. In diesem Beispiel bedeutet dies, dass Sie abhängig von den Ergebnissen der Neuerstellung des linken Zweigs beispielsweise nichts anderes als den rechten Zweig eines Knotens tun können.

Aus historischen Gründen Traversableenthält die Klasse auch eine monadische Version von traverseaufgerufen mapM. In jeder Hinsicht mapMist es dasselbe wie traverse- es existiert als separate Methode, weil es Applicativeerst später zu einer Oberklasse von wurde Monad.

Wenn Sie dies in einer unreinen Sprache implementieren würden, fmapwäre dies dasselbe wie traverse, da es keine Möglichkeit gibt, Nebenwirkungen zu verhindern. Sie können es nicht als Schleife implementieren, da Sie Ihre Datenstruktur rekursiv durchlaufen müssen. Hier ist ein kleines Beispiel, wie ich es in Javascript machen würde:

Node.prototype.traverse = function (f) {
  return new Node(this.l.traverse(f), f(this.k), this.r.traverse(f));
}

Wenn Sie es so implementieren, beschränken Sie sich auf die Effekte, die die Sprache zulässt. Wenn Sie zB Nichtdeterminismus wollen (was die Listeninstanz von Anwendungsmodellen ist) und Ihre Sprache nicht eingebaut ist, haben Sie kein Glück.

traverseverwandelt Dinge in a Traversablein ein Traversablevon Dingen "in" ein Applicative, gegeben eine Funktion, die Applicatives aus Dingen macht.

Verwenden wir Maybeas Applicativeund listen as auf Traversable. Zuerst brauchen wir die Transformationsfunktion:

half x = if even x then Just (x `div` 2) else Nothing

Wenn also eine Zahl gerade ist, bekommen wir die Hälfte davon (innerhalb von a Just), sonst bekommen wir Nothing. Wenn alles "gut" läuft, sieht es so aus:

traverse half [2,4..10]
--Just [1,2,3,4,5]

Aber...

traverse half [1..10]
-- Nothing

Der Grund ist, dass die <*>Funktion verwendet wird, um das Ergebnis zu erstellen, und wenn eines der Argumente ist Nothing, kehren wir Nothingzurück.

Ein anderes Beispiel:

rep x = replicate x x

Diese Funktion generiert eine Längenliste xmit dem Inhalt x, zB rep 3= [3,3,3]. Was ist das Ergebnis von traverse rep [1..3]?

Wir bekommen die Teilergebnisse [1], [2,2]und [3,3,3]unter Verwendung rep. Nun ist die Semantik von Listen Applicativeswird „alle Kombinationen nehmen“, zB (+) <$> [10,20] <*> [3,4]ist [13,14,23,24].

"Alle Kombinationen" von [1]und [2,2]sind zweimal [1,2]. Alle Kombinationen sind zweimal [1,2]und [3,3,3]sechsmal [1,2,3]. Also haben wir:

traverse rep [1..3]
--[[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3]]

Ich denke, es ist am einfachsten zu verstehen sequenceA, traversewie folgt definiert werden kann.

traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
traverse f = sequenceA . fmap f

sequenceA sequenziert die Elemente einer Struktur von links nach rechts und gibt eine Struktur mit derselben Form zurück, die die Ergebnisse enthält.

sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
sequenceA = traverse id

Sie können sich auch vorstellen sequenceA, die Reihenfolge von zwei Funktoren umzukehren, z. B. von einer Liste von Aktionen in eine Aktion zu wechseln, die eine Liste von Ergebnissen zurückgibt.

Nehmen Sie also traverseeine Struktur und wenden Sie fan, um jedes Element in der Struktur in eine Anwendung umzuwandeln. Anschließend werden die Auswirkungen dieser Anwendungen von links nach rechts sequenziert, wobei eine Struktur mit derselben Form zurückgegeben wird, die die Ergebnisse enthält.

Sie können es auch mit vergleichen Foldable, wodurch die zugehörige Funktion definiert wird traverse_.

traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()

Sie sehen also, dass der Hauptunterschied zwischen Foldableund darin Traversablebesteht, dass Sie mit letzterem die Form der Struktur beibehalten können, während Sie mit ersterem das Ergebnis in einen anderen Wert falten müssen.

Ein einfaches Beispiel für seine Verwendung ist die Verwendung einer Liste als durchlaufbare Struktur und IOals Anwendung:

λ> import Data.Traversable
λ> let qs = ["name", "quest", "favorite color"]
λ> traverse (\thing -> putStrLn ("What is your " ++ thing ++ "?") *> getLine) qs
What is your name?
Sir Lancelot
What is your quest?
to seek the holy grail
What is your favorite color?
blue
["Sir Lancelot","to seek the holy grail","blue"]

Während dieses Beispiel eher nicht aufregend ist, werden die Dinge interessanter, wenn traversees für andere Arten von Behältern oder für andere Anwendungen verwendet wird.

Es ist irgendwie so fmap , nur dass Sie Effekte innerhalb der Mapper-Funktion ausführen können, wodurch auch der Ergebnistyp geändert wird.

Stellen Sie sich eine Liste von Ganzzahlen vor, die Benutzer-IDs in einer Datenbank darstellen : [1, 2, 3]. Wenn Sie fmapdiese Benutzer-IDs zu Benutzernamen verwenden möchten , können Sie keine herkömmliche verwendenfmap , da Sie innerhalb der Funktion auf die Datenbank zugreifen müssen, um die Benutzernamen zu lesen (was einen Effekt erfordert - in diesem Fall mithilfe der IOMonade).

Die Unterschrift von traverseist:

traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

Mit traversekönnen Sie Effekte ausführen. Daher sieht Ihr Code zum Zuordnen von Benutzer-IDs zu Benutzernamen folgendermaßen aus:

mapUserIDsToUsernames :: (Num -> IO String) -> [Num] -> IO [String]
mapUserIDsToUsernames fn ids = traverse fn ids

Es gibt auch eine Funktion namens mapM:

mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

Jede Verwendung von mapMkann durch ersetzt werden traverse, aber nicht umgekehrt. mapMfunktioniert nur für Monaden, währendtraverse ist aber allgemeiner.

Wenn Sie nur einen Effekt erzielen wollen und keinen nützlichen Wert zurückgeben, gibt es traverse_und mapM_Versionen dieser Funktionen, die beide den Rückgabewert der Funktion ignoriert und sind etwas schneller.

traverse ist die Schleife. Die Implementierung hängt von der zu durchlaufenden Datenstruktur ab. Das könnte eine Liste, Baum, sein Maybe, Seq(uss), oder etwas , das eine generische Art und Weise hat der wird über so etwas wie eine for-Schleife oder rekursive Funktion durchlaufen. Ein Array hätte eine for-Schleife, eine Liste eine while-Schleife, einen Baum, entweder etwas Rekursives oder die Kombination eines Stapels mit einer while-Schleife; In funktionalen Sprachen benötigen Sie diese umständlichen Schleifenbefehle jedoch nicht: Sie kombinieren den inneren Teil der Schleife (in Form einer Funktion) direkter und weniger ausführlich mit der Datenstruktur.

Mit der TraversableTypklasse könnten Sie Ihre Algorithmen wahrscheinlich unabhängiger und vielseitiger schreiben. Aber meiner Erfahrung nach Traversablewird dies normalerweise nur verwendet, um Algorithmen einfach auf vorhandene Datenstrukturen zu kleben. Es ist sehr schön, keine ähnlichen Funktionen für verschiedene qualifizierte Datentypen schreiben zu müssen.