Haskell

https://panorama.pub/news/skolniki-kotoryh-s-1-klassa

На картинке написано:

— Я прогаю на Haskell

— Это что значит?

— Это значит, что он боится побочных эффектов!

— Ничего подобного!

— printf («Hello world!"\n);

— Патрик, хорош, ты его перепугал!

Поясняет Паша Вавилин, наставник на курсе по Python.

В функциональном программировании есть понятие side-эффекта: это когда функция не только возвращает результат, но и делает что-то кроме. Например, вывести что-то на экран, записать в файл, поменять что-то внутри какой-то другой переменной в программе — это всё побочные эффекты (side effects).

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

Дополнительно пара слов от «Кода»: мы как-то давно писали про чистые функции. Идея в том, что чистой считается та функция, которая получила что-то на вход, обработала, выдала на выходе. И мы должны быть уверены, что все эти вычисления произошли только внутри функции и ничего другого в программе не было затронуто.

Например, у нас есть переменная в корне программы. Мы её используем, чтобы считать какие-то нужные нам события. Если какая-то функция в программе добавляет что-то в эту переменную, это побочный эффект.

Вот мы программируем себе и положили побочный эффект «Увеличить глобальный счётчик» в одну из функций. Вызвали её по делу. Она правильно всё посчитала и увеличила счётчик. Пока что ничего страшного.

Через полгода другой программист поддерживает за нас программу. Видит: «О, эта функция делает то, что мне нужно, вызову её». И он не знает, что, помимо своей основной работы, она ещё увеличивает глобальный счётчик (забыл про побочный эффект). Он её вызывает в цикле тысячу раз, и она тысячу раз увеличивает счётчик. А счётчик, в свою очередь, завязан на что-то другое в программе. И в итоге вся программа ломается.

Чтобы такого не было, разработчики стремятся писать чистые функции. А в функциональных языках и подавно.

Добрый вечер. Продолжаю делиться наблюдениями из нашей группы по изучению  Haskell (
часть 1,  часть 2  ). Скорее всего, пишу текст для себя, попутно повторяя \ вспоминая пройденный материал. Итак, поехали.

Прошли базовые функции для списков: head, tail, take, drop, !! . Отдельная благодарность автору книги в этом моменте, что он не стал подробно расписывать, какие же крутые это вещи, а просто обозначил их как API. Берите, пользуйтесь. Вы же не глупые: сможете различить, что значит взять голову списка, а что значит взять первые 5 элементов. Так что эту тему проскочили быстро.

А дальше начались базовые определения даже не столько языка Haskell, а  программирования в целом. Type, scope, local bindings, data structure, list... Хорошо, что у каждого из нас есть какой-никакой программистский бэкграунд. Поэтому именно эти определения у нас не вызвали затруднения. А вот следующие термины уже нас напрягли.

Data declaration (0), type constructor (1), data constructor (2). Вот в наших головах слово "конструктор" связано с  тем, что это функция, которая должна что-то создать. Конструктор может принимать аргументы. А когда мы пишем (0) data (1) Bool = (2) False | (2) True - тут вроде как ничего не создается в прошлом, привычном для нас понимании. Ну ок, допустим, что мы ввели новую сущность тип Bool. Да, он появился на свет, типа  создался. Но False, True - почему  их называем конструкторами? Это же значения, это данные, которые "населяют" наш Bool. Их не вызывают. Бесспорно , какие-то догадки есть. Кто-то наперед заглянул, кто-то гугл помучил. Но все равно очень непривычно. В этом моменте впервые столкнулись с тем, что наш предыдущий опыт скорее даже мешал, чем помогал в осознании текста книги.

Затем автор ввел понятие переменной типа (type variable). Заставил нас различать оператор ++ и функцию concat. Заставил прочувствовать разницу следующих сигнатур: 1) [a]->[a]->[a] и 2) [[a]] -> [a]. Признаюсь,  вроде бы такой простой пример, но у меня с ним трудности. До сих пор спотыкаюсь на различии этих видов конкатенации. И там, и тут возвращаются списки. А как они получились - мне не важно. Может, как станет важно, так и все станет легко и прозрачно.

Дальше нас начали знакомить с базовыми типами. Научились отличать смысл следующих слов: Integral, Int, Integer. Через пару страниц посмеялись, что, оказывается, в комплект входят Int8, Int16... Все познается в сравнении. JS, твой универсальный double на все времена по сравнению с зоопарком в Haskell кажется таким простым. А Integer от Haskell удивительно похож по своей задумке на BigInt в JS. Вот интересно,  а как можно считать бесконечно большие числа на компьютере, если не через биты памяти того же стандарта IEE-754? Переводить в строки, строить отдельный парсер... Кто знает, напиши в комментариях, в чем там фокус?

В итоге, мы научились чувствовать, что в Haskell есть отдельный уровень типизации, а есть отдельный уровень вычислений. Путать их нехорошо. Их надо держать под своим контролем в связке и согласованности. Еще попутно автор намекал, что нас ждут Type classes. Просил не расстраиваться. Сказал, что пока думайте о них как об интерфейсах в классических языках программирования про ООП. А потом, когда дойдем до этой темы, там все нам объяснит. Брр. Опять отсылка в будущее. Бесит.

А пока мы остановились на упражнениях по пройденному материалу: базовые операции над числами, строками, списками. Думается, что раз мы честно проходили материал и не позволяли халявить друг другу, то проблем с решением этих упражнений у нас не будет. Ну а если будут... - предлагайте ваши варианты =)