Может кто-нибудь объяснить функцию обхода в Haskell?

Я пытаюсь и не могу найти эту traverseфункцию Data.Traversable. Я не вижу в этом смысла. Поскольку я пришел из императивного фона, может ли кто-нибудь объяснить мне это с точки зрения императивного цикла? Псевдокод был бы очень признателен. Спасибо.

traverseто же самое, что и fmap, за исключением того, что он также позволяет запускать эффекты, пока вы перестраиваете структуру данных.

Взгляните на пример из Data.Traversableдокументации.

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

FunctorЭкземпляр Treeбудет:

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)

Он перестраивает все дерево, применяя fк каждому значению.

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

TraversableЭкземпляр почти то же самое, за исключением того, что конструкторы вызываются в аппликативном стиле. Это означает, что мы можем иметь (побочные) эффекты при восстановлении дерева. Аппликатив почти такой же, как и монады, за исключением того, что эффекты не могут зависеть от предыдущих результатов. В этом примере это означает, что вы не можете сделать что-то отличное от правой ветви узла, например, в зависимости от результатов восстановления левой ветви.

По историческим причинам, Traversableкласс также содержит одноместную версию traverseназывается mapM. Для всех намерений и целей mapMэто то же самое, что и traverse- он существует как отдельный метод, потому что Applicativeтолько позже стал суперклассом Monad.

Если бы вы реализовали это на нечистом языке, это fmapбыло бы то же самое, что и traverse, поскольку нет способа предотвратить побочные эффекты. Вы не можете реализовать его как цикл, поскольку вам нужно рекурсивно перемещаться по структуре данных. Вот небольшой пример того, как я бы сделал это в Javascript:

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

Такая реализация ограничивает вас теми эффектами, которые позволяет язык. Если вам нужен недетерминизм (который является экземпляром списка моделей Applicative), а в вашем языке он не встроен, вам не повезло.

traverseпревращает вещи внутри a Traversableв a Traversableвещей "внутри" an Applicative, учитывая функцию, которая делает Applicatives из вещей.

Давайте использовать Maybeas Applicativeи перечислить как Traversable. Для начала нам понадобится функция преобразования:

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

Итак, если число четное, мы получаем его половину (внутри a Just), иначе мы получаем Nothing. Если все идет "хорошо", это выглядит так:

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

Но...

traverse half [1..10]
-- Nothing

Причина в том, что <*>функция используется для построения результата, и когда один из аргументов есть Nothing, мы Nothingвозвращаемся.

Другой пример:

rep x = replicate x x

Эта функция генерирует список длины xс содержимым x, например rep 3= [3,3,3]. Что в результате traverse rep [1..3]?

Мы получаем частичные результаты [1], [2,2]и [3,3,3]использования rep. Теперь семантика списков , как Applicativesэто «принимать все комбинации», например , (+) <$> [10,20] <*> [3,4]есть [13,14,23,24].

«Все комбинации» [1]и [2,2]составляют два раза [1,2]. Все комбинации два раза [1,2]и [3,3,3]шесть раз [1,2,3]. Итак, у нас есть:

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

Я думаю, что это легче всего понять в терминах sequenceA, которые traverseможно определить следующим образом.

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

sequenceA объединяет элементы структуры слева направо, возвращая структуру той же формы, содержащую результаты.

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

Вы также можете думать об sequenceAизменении порядка двух функторов на противоположное, например, переход от списка действий к действию, возвращающему список результатов.

Таким образом, traverseберется некоторая структура и применяется fдля преобразования каждого элемента в структуре в некоторый аппликатив, а затем он упорядочивает эффекты этих аппликативов слева направо, возвращая структуру той же формы, содержащую результаты.

Вы также можете сравнить его с Foldable, который определяет связанную функцию traverse_.

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

Таким образом, вы можете видеть, что ключевое различие между Foldableи Traversableзаключается в том, что последний позволяет вам сохранить форму структуры, тогда как первый требует, чтобы вы свернули результат в другое значение.

Простым примером его использования является использование списка в качестве проходимой структуры и IOв качестве аппликатива:

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

Хотя этот пример довольно неинтересный, все становится интереснее, когда traverseон используется с другими типами контейнеров или с другими приложениями.

Это вроде как fmap, за исключением того, что вы можете запускать эффекты внутри функции сопоставления, которая также меняет тип результата.

Представьте список целых чисел , представляющие идентификаторы пользователей в базе данных: [1, 2, 3]. Если вы хотите, чтобы fmapэти идентификаторы пользователей были добавлены к именам пользователей, вы не можете использовать традиционные fmap, потому что внутри функции вам нужно получить доступ к базе данных, чтобы прочитать имена пользователей (что требует эффекта - в данном случае с помощью IOмонады).

Подпись traverse:

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

С помощью traverse, вы можете создавать эффекты, поэтому ваш код для сопоставления идентификаторов пользователей с именами пользователей выглядит так:

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

Также есть функция mapM:

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

Любое использование mapMможно заменить на traverse, но не наоборот. mapMработает только для монад, тогда как traverseявляется более общим.

Если вы просто хотите добиться эффекта и не возвращать какое-либо полезное значение, существуют traverse_и mapM_версии этих функций, обе из которых игнорируют возвращаемое значение из функции и работают немного быстрее.

traverse это петля. Его реализация зависит от структуры данных, по которой нужно пройти. Это может быть список, дерево, Maybe, Seq(uence), или что - нибудь , что имеет общий способ пересекаемой через что - то подобное для цикла или рекурсивной функции. Массив будет иметь цикл for, список - цикл while, дерево - либо что-то рекурсивное, либо комбинацию стека с циклом while; но в функциональных языках вам не нужны эти громоздкие команды цикла: вы объединяете внутреннюю часть цикла (в форме функции) со структурой данных более прямым и менее подробным образом.

С Traversableклассом типов вы, вероятно, могли бы написать свои алгоритмы более независимыми и универсальными. Но мой опыт говорит, что Traversableэто обычно используется только для простого приклеивания алгоритмов к существующим структурам данных. Довольно хорошо, что не нужно писать похожие функции для разных типов данных.