Adakah yang bisa menjelaskan fungsi traverse di Haskell?

Saya mencoba dan gagal mendapatkan traversefungsi dari Data.Traversable. Saya tidak dapat memahami maksudnya. Karena saya berasal dari latar belakang imperatif, dapatkah seseorang menjelaskannya kepada saya dalam istilah loop imperatif? Pseudo-code akan sangat dihargai. Terima kasih.

traversesama dengan fmap, kecuali bahwa ini juga memungkinkan Anda menjalankan efek saat Anda membangun kembali struktur data.

Lihat contoh dari Data.Traversabledokumentasi.

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

The Functorcontoh Treeakan menjadi:

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)

Itu membangun kembali seluruh pohon, menerapkan fke setiap nilai.

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

The Traversablecontoh hampir sama, kecuali konstruktor disebut dalam gaya aplikatif. Ini berarti bahwa kita dapat memiliki efek (samping) saat membangun kembali pohon tersebut. Aplikatif hampir sama dengan monad, hanya saja efeknya tidak dapat bergantung pada hasil sebelumnya. Dalam contoh ini berarti Anda tidak dapat melakukan sesuatu yang berbeda ke cabang kanan dari sebuah node tergantung pada hasil dari membangun kembali cabang kiri misalnya.

Untuk alasan sejarah, Traversablekelas juga berisi versi monadik yang traversedisebut mapM. Untuk semua maksud dan tujuan mapMsama dengan traverse- itu ada sebagai metode terpisah karena Applicativehanya kemudian menjadi superclass dari Monad.

Jika Anda menerapkan ini dalam bahasa yang tidak murni, fmapakan sama dengan traverse, karena tidak ada cara untuk mencegah efek samping. Anda tidak dapat mengimplementasikannya sebagai loop, karena Anda harus melintasi struktur data Anda secara rekursif. Berikut adalah contoh kecil bagaimana saya melakukannya di Javascript:

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

Menerapkannya seperti ini membatasi Anda pada efek yang dimungkinkan oleh bahasa. Jika Anda menginginkan non-determinisme (yang merupakan contoh daftar model Aplikatif) dan bahasa Anda tidak memiliki bawaan, Anda kurang beruntung.

traversemengubah hal-hal di dalam a Traversablemenjadi Traversablesesuatu "di dalam" an Applicative, diberi fungsi yang membuat Applicatives dari benda-benda.

Mari gunakan Maybesebagai Applicativedan daftar sebagai Traversable. Pertama kita membutuhkan fungsi transformasi:

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

Jadi jika angkanya genap, kita mendapatkan setengahnya (di dalam a Just), kalau tidak kita dapatkan Nothing. Jika semuanya berjalan "baik", akan terlihat seperti ini:

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

Tapi...

traverse half [1..10]
-- Nothing

Alasannya adalah bahwa <*>fungsi tersebut digunakan untuk membangun hasil, dan jika salah satu argumennya adalah Nothing, kami Nothingkembali.

Contoh lain:

rep x = replicate x x

Fungsi ini menghasilkan daftar panjang xdengan konten x, misalnya rep 3= [3,3,3]. Apa hasil dari traverse rep [1..3]?

Kami mendapatkan hasil parsial [1], [2,2]dan [3,3,3]menggunakan rep. Sekarang semantik daftar sebagai Applicativesyang "mengambil semua kombinasi", misalnya (+) <$> [10,20] <*> [3,4]adalah [13,14,23,24].

"Semua kombinasi" [1]dan [2,2]dua kali [1,2]. Semua kombinasi dua kali [1,2]dan [3,3,3]enam kali [1,2,3]. Jadi kita punya:

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

Saya pikir itu paling mudah dipahami dalam istilah sequenceA, seperti yang traversedapat didefinisikan sebagai berikut.

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

sequenceA mengurutkan elemen-elemen struktur dari kiri ke kanan, mengembalikan struktur dengan bentuk yang sama yang berisi hasil.

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

Anda juga dapat menganggap sequenceAsebagai membalik urutan dua fungsi, misalnya beralih dari daftar tindakan menjadi tindakan yang mengembalikan daftar hasil.

Jadi traversemengambil beberapa struktur, dan berlaku funtuk mengubah setiap elemen dalam struktur menjadi beberapa aplikatif, kemudian mengurutkan efek dari aplikasi tersebut dari kiri ke kanan, mengembalikan struktur dengan bentuk yang sama berisi hasil.

Anda juga dapat membandingkannya dengan Foldable, yang mendefinisikan fungsi terkait traverse_.

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

Jadi, Anda dapat melihat bahwa perbedaan utama antara Foldableand Traversableis memungkinkan Anda untuk mempertahankan bentuk struktur, sedangkan yang pertama mengharuskan Anda melipat hasilnya menjadi nilai lain.

Contoh sederhana penggunaannya adalah menggunakan list sebagai struktur yang dapat dilalui, dan IOsebagai aplikatif:

λ> 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"]

Meskipun contoh ini agak tidak menarik, hal-hal menjadi lebih menarik ketika traversedigunakan pada jenis wadah lain, atau menggunakan aplikasi lain.

Ini seperti fmap, kecuali Anda dapat menjalankan efek di dalam fungsi mapper, yang juga mengubah jenis hasil.

Bayangkan daftar bilangan bulat yang mewakili ID pengguna dalam database: [1, 2, 3] . Jika Anda ingin fmapID pengguna ini ke nama pengguna, Anda tidak dapat menggunakan tradisional fmap, karena di dalam fungsi Anda perlu mengakses database untuk membaca nama pengguna (yang memerlukan efek - dalam hal ini, menggunakan IOmonad).

Tanda tangan dari traverse adalah:

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

Dengan traverse , Anda dapat melakukan efek, oleh karena itu, kode Anda untuk memetakan ID pengguna ke nama pengguna terlihat seperti:

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

Ada juga fungsi yang disebut mapM :

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

Setiap penggunaan mapMbisa diganti dengantraverse , tapi tidak bisa sebaliknya. mapMhanya berfungsi untuk monad, sedangkan traverselebih umum.

Jika Anda hanya ingin mencapai efek dan tidak mengembalikan nilai berguna apa pun, ada traverse_dan mapM_versi fungsi ini, keduanya mengabaikan nilai pengembalian dari fungsi dan sedikit lebih cepat.

traverse adalah lingkarannya. Implementasinya bergantung pada struktur data yang akan dilalui. Itu mungkin daftar, pohon Maybe,,Seq (pengaruh), atau apapun yang memiliki cara generik yang dilalui melalui sesuatu seperti untuk loop atau fungsi rekursif. Sebuah array akan memiliki for-loop, list a while-loop, sebuah pohon entah sesuatu yang rekursif atau kombinasi tumpukan dengan while-loop; tetapi dalam bahasa fungsional Anda tidak memerlukan perintah perulangan yang rumit ini: Anda menggabungkan bagian dalam perulangan (dalam bentuk fungsi) dengan struktur data secara lebih langsung dan lebih sedikit.

Dengan kelas Traversabletipe, Anda mungkin bisa menulis algoritme Anda lebih independen dan serbaguna. Tapi pengalaman saya mengatakan, itu Traversablebiasanya hanya digunakan untuk sekadar merekatkan algoritme ke struktur data yang ada. Cukup menyenangkan untuk tidak perlu menulis fungsi serupa untuk tipe data berbeda yang memenuhi syarat juga.