Форма входа
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 во имя добра! - Миран Липовача
Шрифт:
-
+
Интервал:
-
+
Закладка:
Сделать
Поскольку выражения do записываются построчно, некоторым людям они могут показаться императивным кодом. Но эти выражения просто находятся в последовательности, поскольку каждое значение в каждой строке зависит от результатов выражений в предыдущих строках вместе с их контекстами (в данном случае контекстом является успешное либо неуспешное окончание их вычислений).
Ещё раз давайте взглянем на то, как выглядел бы этот кусок кода, если бы мы не использовали монадические стороны типа Maybe:
routine :: Maybe Pole
routine =
case Just (0, 0) of
Nothing –> Nothing
Just start –> case landLeft 2 start of
Nothing –> Nothing
Just first –> case landRight 2 first of
Nothing –> Nothing
Just second –> landLeft 1 second
Видите, как в случае успеха образец start получает значение кортежа внутри Just (0, 0), образец first получает значение результата выполнения landLeft 2 start и т. д.?
Если мы хотим бросить Пьеру банановую кожуру в нотации do, можем сделать следующее:
routine :: Maybe Pole
routine = do
start <– return (0, 0)
first <– landLeft 2 start
Nothing
second <– landRight 2 first
landLeft 1 second
Когда мы записываем в нотации do строку, не связывая монадическое значение с помощью символа <–, это похоже на помещение вызова функции >> за монадическим значением, результат которого мы хотим игнорировать. Мы помещаем монадическое значение в последовательность, но игнорируем его результат, так как нам неважно, чем он является. Плюс ко всему это красивее, чем записывать эквивалентную форму _ <– Nothing.
Когда использовать нотацию do, а когда явно использовать вызов операции >>=, зависит от вас. Я думаю, этот пример хорошо подходит для того, чтобы явно использовать операцию >>=, потому что каждый шаг прямо зависит от предыдущего. При использовании нотации do мы должны явно записывать, на каком шесте садятся птицы, но каждый раз мы просто используем шест, который был результатом предшествующего приземления. Тем не менее это дало нам некоторое представление о нотации do.
Сопоставление с образцом и неудача в вычислениях
Привязывая монадические значения к идентификаторам в нотации do, мы можем использовать сопоставление с образцом так же, как в выражениях let и параметрах функции. Вот пример сопоставления с образцом в выражении do:
justFirst :: Maybe Char
justFirst = do
(x:xs) <– Just "привет"
return x
Мы используем сопоставление с образцом для получения первого символа строки "привет", а затем возвращаем его в качестве результата. Поэтому justFirst возвращает значение Just 'п'.
Что если бы это сопоставление с образцом окончилось неуспешно? Когда сопоставление с образцом в функции оканчивается не успешно, происходит сопоставление со следующим образцом. Если сопоставление проходит по всем образцам для данной функции с невыполнением их условий, выдаётся ошибка и происходит аварийное завершение работы программы. С другой стороны, сопоставление с образцом, окончившееся неудачей в выражениях let, приводит к незамедлительному возникновению ошибки, потому что в выражениях let отсутствует механизм прохода к следующему образцу при невыполнении условия.
Когда сопоставление с образцом в выражении do завершается неуспешно, функция fail (являющаяся частью класса типов Monad) позволяет ему вернуть в результате неудачу в контексте текущей монады, вместо того чтобы привести к аварийному завершению работы программы. Вот реализация функции по умолчанию:
fail :: (Monad m) => String –> m a
fail msg = error msg
Так что по умолчанию она действительно заставляет программу завершаться аварийно. Но монады, содержащие в себе контекст возможной неудачи (как тип Maybe), обычно реализуют её самостоятельно. Для типа Maybe она реализована следующим образом:
fail _ = Nothing
Она игнорирует текст сообщения об ошибке и производит значение Nothing. Поэтому, когда сопоставление с образцом оканчивается неуспешно в значении типа Maybe, записанном в нотации do, результат всего значения будет равен Nothing. Предпочтительнее, чтобы ваша программа завершила свою работу неаварийно. Вот выражение do, включающее сопоставление с образцом, которое обречено на неудачу:
wopwop :: Maybe Char
wopwop = do
(x:xs) <– Just ""
return x
Сопоставление с образцом оканчивается неуспешно, поэтому эффект аналогичен тому, как если бы вся строка с образцом была заменена значением Nothing. Давайте попробуем это:
ghci> wopwop
Nothing
Неуспешно окончившееся сопоставление с образцом вызвало неуспех только в контексте нашей монады, вместо того чтобы вызвать неуспех на уровне всей программы. Очень мило!..
Списковая монада
До сих пор вы видели, как значения типа Maybe могут рассматриваться в качестве значений с контекстом неудачи, и как мы можем ввести в код обработку неуспешно оканчивающихся вычислений, используя оператор >>= для передачи их функциям. В этом разделе мы посмотрим, как использовать монадическую сторону списков, чтобы внести в код недетерминированность в ясном и «читабельном» виде.
В главе 11 мы говорили о том, каким образом списки представляют недетерминированные значения, когда они используются как аппликативные функторы. Значение вроде 5 является детерминированным – оно имеет только один результат, и мы точно знаем, какой он. С другой стороны, значение вроде [3,8,9] содержит несколько результатов, поэтому мы можем рассматривать его как одно значение, которое в то же время, по сути, является множеством значений. Использование списков в качестве аппликативных функторов хорошо демонстрирует эту недетерминированность:
ghci> (*) <$> [1,2,3] <*> [10,100,1000]
[10,100,1000,20,200,2000,30,300,3000]
В окончательный список включаются все возможные комбинации умножения элементов из левого списка на элементы правого. Когда дело касается недетерминированности, у нас есть много вариантов выбора, поэтому мы просто пробуем их все. Это означает, что результатом тоже является недетерминированное значение, но оно содержит намного больше результатов.
Этот контекст недетерминированности очень красиво переводится в монады. Вот как выглядит экземпляр класса Monad для списков:
instance Monad [] where
return x = [x]
xs >>= f = concat (map f xs)
fail _ = []
Как вы знаете, функция return делает то же, что и функция pure, и вы уже знакомы с функцией return для списков. Она принимает значение и помещает его в минимальный контекст по умолчанию, который по-прежнему возвращает это значение. Другими словами, функция return создаёт список, который содержит только одно это значение в качестве своего результата. Это полезно, когда нам нужно просто обернуть обычное значение в список, чтобы оно могло взаимодействовать с недетерминированными значениями.
Суть операции >>= состоит в получении значения с контекстом (монадического значения) и передаче его функции, которая принимает обычное значение и возвращает значение, обладающее контекстом. Если бы эта функция просто возвращала обычное значение вместо значения с контекстом, то операция >>= не была бы столь полезна: после первого применения контекст был бы утрачен.
Давайте попробуем передать функции недетерминированное значение:
ghci> [3,4,5] >>= x –> [x,-x]
[3,-3,4,-4,5,-5]
Когда мы использовали операцию >>= со значениями типа Maybe, монадическое значение передавалось в функцию с заботой о возможных неудачах. Здесь она заботится за нас о недетерминированности.
Список [3,4,5] является недетерминированным значением, и мы передаём его в функцию, которая тоже возвращает недетерминированное значение. Результат также является недетерминированным, и он представляет все возможные результаты получения элементов из списка [3,4,5] и передачи их функции x –> [x,–x]. Эта функция принимает число и производит два результата: один взятый со знаком минус и один неизменный. Поэтому когда мы используем операцию >>= для передачи этого списка функции, каждое число берётся с отрицательным знаком, а также сохраняется неизменным. Образец x в анонимной функции принимает каждое значение из списка, который ей передаётся.
На этой странице вы можете бесплатно читать книгу Изучай Haskell во имя добра! - Миран Липовача бесплатно.
Похожие на Изучай Haskell во имя добра! - Миран Липовача книги
- Право на ошибку (СИ) - Устинова Юлия "Julia Joe" - Короткие любовные романы
- Современная философия – жертва неадекватного перевода западных философов - Иван Деревянко - Науки: разное
- Под звуки музыки - Олег Синицын - Боевая фантастика
- Правила в исключениях. Записки репетитора по английскому языку - Кирилл Шатилов - Языкознание
- Английский язык за 30 минут в день. Легкий способ выучить английский язык по методу Майкла Томаса - Майкл Томас - Руководства
