Форма входа
0/0
Изучай Haskell во имя добра! - Миран Липовача
- Дата:07.05.2025
- Категория: Компьютеры и Интернет / Программирование
- Название: Изучай Haskell во имя добра!
- Автор: Миран Липовача
- Просмотров:0
- Комментариев:0
Уважаемые читатели!
Тут можно читать бесплатно Изучай Haskell во имя добра! - Миран Липовача. Жанр: Программирование. Так же Вы можете читать полную версию (весь текст) онлайн книги без регистрации и SMS на сайте Knigi-online.info (книги онлайн) или прочесть краткое содержание, описание, предисловие (аннотацию) от автора и ознакомиться с отзывами (комментариями) о произведении.
Описание онлайн-книги Изучай Haskell во имя добра! - Миран Липовача:
На взгляд автора, сущность программирования заключается в решении проблем. Программист всегда думает о проблеме и возможных решениях – либо пишет код для выражения этих решений.Язык Haskell имеет множество впечатляющих возможностей, но главное его свойство в том, что меняется не только способ написания кода, но и сам способ размышления о проблемах и возможных решениях. Этим Haskell действительно отличается от большинства языков программирования. С его помощью мир можно представить и описать нестандартным образом. И поскольку Haskell предлагает совершенно новые способы размышления о проблемах, изучение этого языка может изменить и стиль программирования на всех прочих.Ещё одно необычное свойство Haskell состоит в том, что в этом языке придаётся особое значение рассуждениям о типах данных. Как следствие, вы помещаете больше внимания и меньше кода в ваши программы.Вне зависимости от того, в каком направлении вы намерены двигаться, путешествуя в мире программирования, небольшой заход в страну Haskell себя оправдает. А если вы решите там остаться, то наверняка найдёте чем заняться и чему поучиться!Эта книга поможет многим читателям найти свой путь к Haskell.Отображения, монады, моноиды и другое!Всё сказано в названии: «Изучай Хаскель во имя добра!» – весёлый иллюстрированный самоучитель по этому сложному функциональному языку.С помощью оригинальных рисунков автора, отсылке к поп-культуре, и, самое главное, благодаря полезным примерам кода, эта книга обучает основам функционального программирования так, как вы никогда не смогли бы себе представить.Вы начнете изучение с простого материала: основы синтаксиса, рекурсия, типы и классы типов. Затем, когда вы преуспеете в основах, начнется настоящий мастер-класс от профессионала: вы изучите, как использовать аппликативные функторы, монады, застежки, и другие легендарные конструкции Хаскеля, о которых вы читали только в сказках.Продираясь сквозь образные (и порой безумные) примеры автора, вы научитесь:• Смеяться в лицо побочным эффектам, поскольку вы овладеете техниками чистого функционального программирования.• Использовать волшебство «ленивости» Хаскеля для игры с бесконечными наборами данных.• Организовывать свои программы, создавая собственные типы, классы типов и модули.• Использовать элегантную систему ввода-вывода Хаскеля, чтобы делиться гениальностью ваших программ с окружающим миром.Нет лучшего способа изучить этот мощный язык, чем чтение «Изучай Хаскель во имя добра!», кроме, разве что, поедания мозга его создателей.Миран Липовача (Miran Lipovača) изучает информатику в Любляне (Словения). Помимо его любви к Хаскелю, ему нравится заниматься боксом, играть на бас-гитаре и, конечно же, рисовать. У него есть увлечение танцующими скелетами и числом 71, а когда он проходит через автоматические двери, он притворяется, что на самом деле открывает их силой своей мысли.
Аудиокнига "Изучай Haskell во имя добра!"
📚 Хотите погрузиться в мир функционального программирования и освоить новый язык программирования? Тогда аудиокнига "Изучай Haskell во имя добра!" от автора Мирана Липовача - это то, что вам нужно!
Главный герой книги, начинающий программист, отправляется в увлекательное путешествие по Haskell, чтобы понять его принципы и особенности. Слушая эту аудиокнигу, вы узнаете, как создавать функциональные программы, работать с типами данных, рекурсией и многим другим.
Автор книги, Миран Липовач, является экспертом в области функционального программирования и преподавателем. Он делится своими знаниями и опытом, помогая слушателям легко освоить новый язык программирования.
На сайте knigi-online.info вы можете бесплатно и без регистрации слушать аудиокниги на русском языке. Здесь собраны бестселлеры и лучшие произведения различных жанров, включая программирование.
Не упустите возможность познакомиться с увлекательным миром Haskell и функционального программирования через аудиокнигу "Изучай Haskell во имя добра!" от Мирана Липовача. Погрузитесь в новые знания и расширьте свой кругозор!
Погрузитесь в мир программирования с категорией аудиокниг: Программирование.
Читем онлайн Изучай Haskell во имя добра! - Миран Липовача
Шрифт:
-
+
Интервал:
-
+
Закладка:
Сделать
ghci> gcd' 8 3
1
Согласуется. Очень хорошо! Теперь мы хотим снабдить наш результат контекстом, а контекстом будет моноидное значение, которое ведёт себя как журнал. Как и прежде, мы используем список строк в качестве моноида. Поэтому тип нашей новой функции gcd' должен быть таким:
gcd' :: Int –> Int –> Writer [String] Int
Всё, что осталось сделать, – снабдить нашу функцию журнальными значениями. Вот код:
import Control.Monad.Writer
gcd' :: Int –> Int –> Writer [String] Int
gcd' a b
| b == 0 = do
tell ["Закончили: " ++ show a]
return a
| otherwise = do
tell [show a ++ " mod " ++ show b ++ " = " ++ show (a `mod` b)]
gcd' b (a `mod` b)
Эта функция принимает два обычных значения Int и возвращает значение типа Writer [String] Int, то есть целое число, обладающее контекстом журнала. В случае, когда параметр b принимает значение 0, мы, вместо того чтобы просто вернуть значение a как результат, используем выражение do для сборки значения Writer в качестве результата. Сначала используем функцию tell, чтобы сообщить об окончании, а затем – функцию return для возврата значения a в качестве результата выражения do. Вместо данного выражения do мы также могли бы написать следующее:
Writer (a, ["Закончили: " ++ show a])
Однако я полагаю, что выражение do проще читать. Далее, у нас есть случай, когда значение b не равно 0. В этом случае мы записываем в журнал, что используем функцию mod для определения остатка от деления a и b. Затем вторая строка выражения do просто рекурсивно вызывает gcd'. Вспомните: функция gcd' теперь, в конце концов, возвращает значение типа Writer, поэтому вполне допустимо наличие строки gcd' b (a `mod` b) в выражении do.
Хотя отслеживание выполнения этой новой функции gcd' вручную может быть отчасти полезным для того, чтобы увидеть, как записи присоединяются в конец журнала, я думаю, что лучше будет взглянуть на картину крупным планом, представляя эти значения как значения с контекстом, и отсюда понять, каким будет окончательный результат.
Давайте испытаем нашу новую функцию gcd'. Её результатом является значение типа Writer [String] Int, и если мы развернём его из принадлежащего ему newtype, то получим кортеж. Первая часть кортежа – это результат. Посмотрим, правильный ли он:
ghci> fst $ runWriter (gcd 8 3)
1
Хорошо! Теперь что насчёт журнала? Поскольку журнал является списком строк, давайте используем вызов mapM_ putStrLn для вывода этих строк на экран:
ghci> mapM_ putStrLn $ snd $ runWriter (gcd 8 3)
8 mod 3 = 2
3 mod 2 = 1
2 mod 1 = 0
Закончили: 1
Даже удивительно, как мы могли изменить наш обычный алгоритм на тот, который сообщает, что он делает по мере развития, просто превращая обычные значения в монадические и возлагая беспокойство о записях в журнал на реализацию оператора >>= для типа Writer!.. Мы можем добавить механизм журналирования почти в любую функцию. Всего лишь заменяем обычные значения значениями типа Writer, где мы хотим, и превращаем обычное применение функции в вызов оператора >>= (или выражения do, если это повышает «читабельность»).
Неэффективное создание списков
При использовании монады Writer вы должны внимательно выбирать моноид, поскольку использование списков иногда очень замедляет работу программы. Причина в том, что списки задействуют оператор конкатенации ++ в качестве реализации метода mappend, а использование данного оператора для присоединения чего-либо в конец списка заставляет программу существенно медлить, если список длинный.
В нашей функции gcd' журналирование происходит быстро, потому что добавление списка в конец в итоге выглядит следующим образом:
a ++ (b ++ (c ++ (d ++ (e ++ f))))
Списки – это структура данных, построение которой происходит слева направо, и это эффективно, поскольку мы сначала полностью строим левую часть списка и только потом добавляем более длинный список справа. Но если мы невнимательны, то использование монады Writer может вызывать присоединение списков, которое выглядит следующим образом:
((((a ++ b) ++ c) ++ d) ++ e) ++ f
Здесь связывание происходит в направлении налево, а не направо. Это неэффективно, поскольку каждый раз, когда функция хочет добавить правую часть к левой, она должна построить левую часть полностью, с самого начала!
Следующая функция работает аналогично функции gcd', но производит журналирование в обратном порядке. Сначала она создаёт журнал для остальной части процедуры, а затем добавляет текущий шаг к концу журнала.
import Control.Monad.Writer
gcdReverse :: Int –> Int –> Writer [String] Int
gcdReverse a b
| b == 0 = do
tell ["Закончили: " ++ show a]
return a
| otherwise = do
result <– gcdReverse b (a `mod` b)
tell [show a ++ " mod " ++ show b ++ " = " ++ show (a `mod` b)]
return result
Сначала она производит рекурсивный вызов и привязывает его значение к значению result. Затем добавляет текущий шаг в журнал, но текущий попадает в конец журнала, который был произведён посредством рекурсивного вызова. В заключение функция возвращает результат рекурсии как окончательный. Вот она в действии:
ghci> mapM_ putStrLn $ snd $ runWriter (gcdReverse 8 3)
Закончили: 1
2 mod 1 = 0
3 mod 2 = 1
8 mod 3 = 2
Она неэффективна, поскольку производит ассоциацию вызовов оператора ++ влево, вместо того чтобы делать это вправо.
Разностные списки
Поскольку списки иногда могут быть неэффективными при добавлении подобным образом, лучше использовать структуру данных, которая всегда поддерживает эффективное добавление. Одной из таких структур являются разностные списки. Разностный список аналогичен обычному списку, только он является функцией, которая принимает список и присоединяет к нему другой список спереди. Разностным списком, эквивалентным списку [1,2,3], была бы функция xs –> [1,2,3] ++ xs. Обычным пустым списком является значение [], тогда как пустым разностным списком является функция xs –> [] ++ xs.
Прелесть разностных списков заключается в том, что они поддерживают эффективную конкатенацию. Когда мы «склеиваем» два списка с помощью оператора ++, приходится проходить первый список (левый операнд) до конца и затем добавлять другой.
f `append` g = xs –> f (g xs)
Вспомните: f и g – это функции, которые принимают списки и добавляют что-либо в их начало. Так, например, если f – это функция ("соба"++) – просто другой способ записи xs –> "dog" ++ xs, а g – это функция ("чатина"++), то f `append` g создаёт новую функцию, которая аналогична следующей записи:
xs –> "соба" ++ ("чатина" ++ xs)
Мы соединили два разностных списка, просто создав новую функцию, которая сначала применяет один разностный список к какому-то одному списку, а затем к другому.
Давайте создадим обёртку newtype для разностных списков, чтобы мы легко могли сделать для них экземпляры класса Monoid:
newtype DiffList a = DiffList { getDiffList :: [a] –> [a] }
Оборачиваемым нами типом является тип [a] –> [a], поскольку разностный список – это просто функция, которая принимает список и возвращает другой список. Преобразовывать обычные списки в разностные и обратно просто:
toDiffList :: [a] –> DiffList a
toDiffList xs = DiffList (xs++)
fromDiffList :: DiffList a –> [a]
fromDiffList (DiffList f) = f []
Чтобы превратить обычный список в разностный, мы просто делаем то же, что делали ранее, превращая его в функцию, которая добавляет его в начало другого списка. Поскольку разностный список – это функция, добавляющая нечто в начало другого списка, то если мы просто хотим получить это нечто, мы применяем функцию к пустому списку!
Вот экземпляр класса Monoid:
instance Monoid (DiffList a) where
mempty = DiffList (xs –> [] ++ xs)
(DiffList f) `mappend` (DiffList g) = DiffList (xs –> f (g xs))
Обратите внимание, что для разностных списков метод mempty – это просто функция id, а метод mappend на самом деле – всего лишь композиция функций. Посмотрим, сработает ли это:
ghci> fromDiffList (toDiffList [1,2,3,4] `mappend` toDiffList [1,2,3])
[1,2,3,4,1,2,3]
Превосходно! Теперь мы можем повысить эффективность нашей функции gcdReverse, сделав так, чтобы она использовала разностные списки вместо обычных:
На этой странице вы можете бесплатно читать книгу Изучай Haskell во имя добра! - Миран Липовача бесплатно.
Похожие на Изучай Haskell во имя добра! - Миран Липовача книги
- Право на ошибку (СИ) - Устинова Юлия "Julia Joe" - Короткие любовные романы
- Современная философия – жертва неадекватного перевода западных философов - Иван Деревянко - Науки: разное
- Под звуки музыки - Олег Синицын - Боевая фантастика
- Правила в исключениях. Записки репетитора по английскому языку - Кирилл Шатилов - Языкознание
- Английский язык за 30 минут в день. Легкий способ выучить английский язык по методу Майкла Томаса - Майкл Томас - Руководства
