В этой статье будет много моих выводов, гипотез и идей. Это моя первая статья, поэтому буду рад услышать аргументированную критику. В статье часто используется псевдокод, чей синтаксис напоминает смесь C#, C++ и Python.

Немного о терминологии

Много времени я программирую на C#, и в этом языке существуют некоторые термины, которые могут ввести в заблуждение программистов на C++:

• Под словом коллекция я подразумеваю любой набор элементов: список, массив, стек, куча, итератор, множество и т.п.
• Говоря список, я подразумеваю динамический массив

Язык программирования – инструмент

Языки можно поделить на две большие группы: предметно-ориентированные языки (aka DSL) и языки общего назначения (ЯОП). DSLи точно можно назвать инструментами, так как они по определению решают конкретную задачу. С языками общего назначения все несколько сложнее. ЯОПы имеют техническую возможность реализовать любой алгоритм, то есть полны по Тьюрингу. Но это не значит, что для каждой задачи будет эффективно использовать язык X, ведь язык Y может подходить для решения каких-то задач лучше.

Под словом “эффективно” я подразумеваю, что программистам будет морально приятно писать код на языке для решения конкретной задачи, а также, что код будет написан за минимальное количество времени.

Рассмотрим банальный пример. C# лучше использовать для написания бекенда сайтов, чем Си. Используя C#, вы делаете вклад в возможность поддержки проекта, уменьшаете порог входа в проект, пишете платформо-независимый код. Си лучше использовать в задачах, где важна производительность или низкоуровневый доступ к ресурсам. Например при написании runtime библиотеки языка, игрового движка или кода под микроконтроллеры с небольшими ресурсами.

Также некоторые языки имеют хорошую поддержку сообщества в каких-то специфических областях. Например C# и C++ – доминируют в создании игр, Python и R – преобладают в data science, JavaScript и PHP – в создании сайтов и т.п. В силу своих реализаций не все ЯОП могут решать задачи друг друга эффективно. Интерпретируемый язык никак не может быть также быстр в исполнении, как статически компилируемый, но может выигрывать в скорости кодирования.

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

А в чем проблема?

Проблемы начинаются тогда, когда мы обнаружим, что используемый язык программирования по какой-то причине не умеет решать специфическую задачу своей области эффективно. Например C# не всегда бывает лаконичен: иногда не хватает функциональной парадигмы или нет возможностей сократить лишний синтаксис при композиции. В таких случаях придется смириться и реализовывать функционал через костыли, например, создавая лишние интерфейсы, нужные чтобы обойти запреты языка.

Python не станет быстрым, C++ не будет хорошо подходить для написания скриптов, а Fortran не получит современный синтаксический сахар.

Если вы программировали на C# и Unity, возможно, вы писали какие-нибудь математические функции или методы-расширения. Я с разочарованием для себя обнаружил, что Unity использует C# 9-той версии, в которой нет обобщенной арифметики (ее введут в C# 11). Скорее всего, красиво и лаконично реализовать какой-нибудь метод SquareMagnitude не получится: придется писать одну и ту же реализацию для каждого типа по отдельности (дженерики не помогут: нет обобщающего интерфейса).

Помимо этих реализаций, было бы неплохо иметь реализацию с типами: byte, sbyte, ushort, uint, ulong, decimal. Хорошо, что метод SquareMagnitude достаточно маленький, но если бы это был большой метод, код стал бы еще хуже. Принцип DRY (don’t repeat yourself) плачет в сторонке.

Extensible Programming

Решением видится расширяемое программирование (Extensible Programming) – это парадигма программирования, когда расширяемость возводится в абсолют. Возможности языка не фиксированы, а могут быть расширены. Программист пишет не только расширяемые модульные программы, но и программирует на расширяемом языке. Программист имеет возможность изменять синтаксис языка, исполняемый движок (компилятор/интерпретатор/JIT’а и т.п.), среду исполнения (environment) – все то, что мы называем Toolchain’ом языка. Эта парадигма позволяет кастомизировать язык программирования, добавлять eDSL (embedded DSL, встроенные в язык. Как пример: LINQ в C#). Зачастую кастомизация даже представляется как одно из основных средств программирования. Например, на расширяемом языке есть возможность добавлять новые синтаксические конструкции, изменять AST, байткод, контролировать процесс компиляции, изменять среду исполнения и т.п. Самые известные из расширяемых языков: Ruby, Lisp, Lua.

Предлагаю посмотреть эту статью на хабре, в которой демонстрируется пример написания простенького генератора кода для элегантных лямбд на Lua. Это пример расширяемого синтаксиса языка. Ruby тоже имеет расширяемый синтаксис, например для него написана библиотека superators19, позволяющая добавлять новые операторы в язык.

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

Моя модель идеального языка программирования

Идея заключается в возможности построить микро-язык на модульной архитектуре, который будет содержать в себе ядро и несколько дополнительных модулей для его комфортного расширения. Сам микро-язык будет не очень полезен, но на его основе можно будет сделать диалекты, которые уже можно будет считать полноценными языками общего назначения. При надобности, программист сможет отключать, модифицировать или добавлять модули в язык. Так язык превратится в набор модулей, буквально конструктор. Чтобы внести изменения в язык, будет достаточно понимать его работу в целом, а также понимать работу только тех модулей, с которыми предстоит работать.

Например, представим что JavaScript сделан по данной идее, и хочется добавить в язык рантайм-проверку типов (на минуту забудем про существование TypeScript). Можно было бы написать модуль, который добавляет немного нового синтаксиса в объявление переменных, обрабатывает AST (т.е. использует модуль парсера) и добавляет в каждое использование переменной/поля/т.п. проверку на ее тип.

Псевдо-код реализации модуля мог бы выглядеть как-то так:

Абстрактные детали реализации

Итак, какие задачи языка мы имеем на данный момент? ЯП должен:

• иметь возможность расширять свои frontend, middle-end, backend
• иметь простой API для расширения
• поддерживать большинство парадигм (функциональное, декларативное программирование)

Сначала разберемся с первыми двумя задачами. Как уже было сказано ранее, архитектура языка будет модульной. Значит нужно просто для каждого модуля предусмотреть возможность интеграции с другими модулями. При этом желательно предоставить интуитивный API для доступа к различным частям модуля. Кроме того, каждому модулю не плохо иметь свое краткое описание работы, ведь для написания своих модулей придется иметь понимание всех модулей, которые должны использоваться.

Рассмотрим пример с созданием простейшего фронтенда. Простой фронтенд может быть разделен на небольших модуля: лексер и парсер. Допустим, программист захотел добавить препроцессор перед лексером. Какой удобный API можно предоставить? По моему мнению, хорошо подходят события. Пусть лексер и парсер имеют события OnPreprocess и OnPostprocess. Таким образом, например, программист будет иметь возможность обработки последовательности лексем уже после ее генерации. Также программист сможет изменять AST уже после его генерации.

Но как добавлять новые правила построения дерева или лексемизации текста? Можно создать методы по типу AddLexerRule, AddParserRule, которые будут принимать в себя экземпляры классов, имплементирующих интерфейсы ILexerNodeBuilder и IParserNodeBuilder. Но стоит учесть, что в большинстве языков грамматика не самая простая, а значит, что парсер желательно делать по мощности LR(k), LALR(k) или ALL(*). Возможно стоит сделать небольшой DSL для этих модулей, так как это сильно упростит поддержку языка в дальнейшем (или использовать уже готовый, такой как ANTLR). DSL поможет программистам не погружаться в технические подробности реализации и достаточно просто добавлять изменения в грамматику.

Но как же коллизии имен? Конечно, они будут возникать гораздо чаще, поэтому стоит предусмотреть некое подобие namespace’ов. Например, если в начале файла написано use parser.math, то парсер активирует дополнение к текущей грамматике, добавляющее математические операторы.

Модули

Что, если язык окажется сложным? Например, парсер будет очень тяжелым, язык будет использовать супероптимизаторы или просто модуль окажется проприетарным. В таком случае желательно иметь возможность разбросать модули по разным физическим местам. Например, чтобы разместить супероптимизатор в облаке, парсер поставить на компьютер с бОльшим количеством оперативной памяти, а доступ к проприетарному модулю давать только через web-request’ы (чтобы нельзя было получить исходный код).

Хорошим решением оказывается представлять модули как web-сервисы. Это делает модули гораздо более гибкими. Плюсы модулей как веб-сервисов:

• можно расположить в разных физических местах
• IDE будет способна контролировать все процессы языка – особенно удобно, если нужно глубокое понимание языка, например просмотр промежуточных представлений
• при возникновении потребности можно легко использовать утиную типизацию над модулями
• можно использовать вообще любые языки программирования и технологии
• модули гораздо проще воспринимать как логически разделенные части – повышается гибкость системы и уменьшается ее связность

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

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

Парадигмы

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

Рассмотрим поддержку функционального программирования. Как известно, сердце функциональной парадигмы – это лямбда-исчисления. Думаю, что как ядро языка – отлично подойдут чистые нетипизированные лямбда-исчисления. Уже с помощью модулей можно дополнять λ-исчисления до system F, λ-исчислений с зависимыми типами или других исчислений. То есть достраивать ядро до нужной мощности и уже на имеющейся основе строить язык. Также фишка такого подхода в том, что, используя синтаксический сахар и монады, в язык можно добавить лаконичное императивное программирование. Но стоит быть аккуратным с чистыми функциями. Нужно учесть, что функция не будет чистой, если внутри себя она использует платформозависимые функции или вызывает внешние нечистые функции.

Но язык, ядром которого будут лямбда-исчисления, скорее всего, не будет иметь возможности быть оптимально скомпилирован под популярные архитектуры (x86-64, ARM, RISC-V). Для языков, которым важна производительность, размер программы, потребление памяти и т.п., предлагаю ввести иное ядро. Это ядро должно быть универсальным для любого императивного языка программирования, а также должно иметь возможность глубоких оптимизаций.

У ядра на лямбда-исчислениях есть еще некоторые проблемы: я не придумал, как устранить зависимости между модулями в такой реализации, поэтому, возможно, будет хорошо эмулировать работу исчислений на байткоде императивного языка. Будет написан еще один модуль, превращающий промежуточное представление лямбда-исчислений в байткод (не скупимся на количество IR’ов ради гибкости и удобства).

Байткод императивного языка

Итак, ядро императивного языка программирования, конечно, будет представлять собой байткод. Сначала я думал использовать какую-нибудь видоизмененную машину Тьюринга, но решил, что она слишком сильно оторвана от текущих процессоров и нет смысла даже пытаться адаптировать ее под современные системы. Самая сложная задача проектирования байткода – он должен подходить под любой императивный язык, но при этом иметь возможность оптимизировать выходной код настолько, насколько это возможно. Сразу же хочется добавить поддержку LLVM для статической компиляции, а также компиляцию в dotnet bytecode, java bytecode для поддержки JIT компиляции. Если тщательно формализовать байткод, то даже есть надежда написать супероптимизатор на middle-end уровне.

Сделать один универсальный байткод, конечно, невозможно. Снова прибегнем к модульной архитектуре. Пусть инструкция байткода представляет собой такой тип:

То есть кортеж из типа байткодовой инструкции и трех списков. Изначально байткод будет иметь только один тип инструкции: call. Массивы содержат только делегаты на функции (указатель + сигнатура + доп. информация). Байткод буквально представляет собой шитый код (threaded code) – массив вызовов функций (но не обязательно чистых). Массивы различаются лишь порядком применения операций. В массив [0] добавляются делегаты, которые должны быть исполнены перед делегатами массивов [1] и [2]. Грубо говоря получаем делегаты, которые обязательно должны быть исполнены перед или после исполнения других делегатов. Зачем это нужно, рассмотрим позже. Стоит отметить, что вместо таких массивов подошел бы также multiset<(float, delegate)> делегатов (отсортированный список по приоритету вызовов).

Существует несколько видов байткода: стековый, регистровый и в SSA форме. Для упрощения будем использовать стековый байткод, так как он легко переводится в регистровую и SSA форму. Да и сам по себе, гораздо более абстрактный. Регистровый байткод имеет привязку к количеству регистров, а байткод должен не зависеть от архитектурных особенностей. SSA форма – удобный вариант, но он более сложный. При разработке модулей он может сильно помешать, так как придется “жанглировать” передачами регистров, строить CFG.

Продолжение байткода

Представим ситуацию. Мы уже имеем минималистичный язык программирования: уже существуют локальные переменные, метки, вызовы внешних функций и другой примитивный функционал. Сейчас типизация динамическая, но хочется внедрить рантайм проверки типов, как в примере с JavaScript. Реализация примерно такая же: добавляем новое правило в лексер, обходим узлы AST с использованием переменной, внедряем assert как ноду перед использованием переменной. Но вдруг программист обнаруживает, что ему не хватает структур в языке. Обычных базовых структур, которые просто хранят значения, в которых нет даже методов (их можно добавить, но без методов проще). Итак, программист написал модуль с поддержкой подобного синтаксиса:

который превращается в подобный байткод:

Главная проблема в том, что ни на этапе AST, ни на этапе байткода инструкции LoadField и SetField не получается распознать, как использование переменной. Конечно, на уровне AST невозможно распознать такую конструкцию, так как создаются новые типы нод. А вот с байткодом есть возможность подружиться, если продумать типы инструкций. Можно сказать, что тип инструкции байткода – это ее тег. Первая мысль – делать строгие инструкции, например SetLocal, LoadGlobal, LoadMethodReference и другие. Но проблема таких типов в том, что они слишком конкретны.

Постараемся развить абстракции. Оставим только инструкции Set и Get, которые будут оперировать интерфейсами (точнее классами/структурами, имплементирующими их) ISettable и IGettable. Чтобы вызвать эти методы, нужны экземпляры классов. Для этого перед каждой установкой или чтением значения будем класть на стек ссылку-обертку на значение. Ссылка, в данном контексте, это не всегда указатель на ячейку памяти. Это абстрактный указатель на само значение. Класс, имплементирующий ISettable и IGettable. Ссылка может быть регистром, реальным указателем или быть ячейкой словаря (map’ы). Рассмотрим пример:

Как видно, логика написана достаточно абстрактно, нет никакой конкретики. Как работает ISettable – неясно, да и не нужно. Наша задача – написать относительно простой, максимально обобщенный код.

Инструкции байткода также могут возвращать значения. Первая мысль реализации: как и в обычных функциях, возвращаем значение через return. Но в байткоде встречаются такие инструкции, как swap. Они принимают два значения и возвращают два значения. Поэтому, для удобства, стоит возвращать значения через аргументы-ссылки, предназначенные только для записи (в C# – ключевое слово out). Например:

Возвращаясь к проблеме типизации и структур, теперь модуль типизации может вставлять проверки перед каждой инструкций типа Set/Get, а модуль структур будет генерировать код установки и получения значений именно через Set и Get. Тут нам и пригодятся три списка делегатов в инструкции. Проверка типов обязана исполнятся перед тем, как основная инструкция будет выполнена, поэтому проверку стоит поместить в нулевой список делегатов. Также плюсом будет то, что модули работают на уровне байткода, а не AST. Это позволит без боли менять фронтенд языка и не переписывать большинство модулей.

Теперь, понимая смысл трех списков, можем дать им названия: pre-ops, main-ops, post-ops – делегаты, исполняемые, соответственно, до, во время и после совершения основной операции.

В результате реализации байткода, придерживаясь таких идей, удастся убрать зависимость между модулями. Модуль типизации может ничего не знать о модуле структур. Аналогично модуль сборщика мусора ничего не будет знать о модуле синтаксического сахара.

Перфоманс байткода

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

Как видно, при достаточно глубоком инлайнинге (2-3 шага) можно сильно упростить код. Уже после инлайнинга, оптимизатор паттернов может сильно упростить некоторые под-коды. Например можно научить оптимизатор распознавать обращение к классу VariableWrapper

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

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

Обсуждаемый байткод легко перевести в байткод виртуальной машины dotnet или JVM. Также не сложно перевести в LLVM IR, чтобы уже этот фреймворк применял сильные оптимизации.

Рассматриваем узкие места

Дебаггинг

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

Зависимости между модулями

В худшем случае, количество зависимостей будет O(n^2), где n – количество модулей. Байткод специально был спроектирован так, чтобы зависимость между модулями была минимальной. Но даже с этим условием все еще стоит стараться делать модули абстрактными и подумать заранее о написании других модулях, которые смогут расширять его исходные возможности. Когда будет написан модуль с типизацией, нужно подумать, как улучшить имеющиеся абстракции для потенциальных будущих модулей с ее улучшением (вспомним лямбда-куб).

Общее API модулей

Также мне нравится идея с веб-сервисами тем, что модулям придется общаться через json’ы. Это сразу заставит продумать API создаваемого модуля. Мучаться с бинарной совместимостью не придется, так как обмен информацией достаточно высокоуровневый и многие проблемы решают такие протоколы как, например, http.

Заключение

Не думаю, что когда-нибудь будет создан один универсальный язык программирования, который подойдет для решения всех задач. Но, скорее всего, именно удобное окружение и продуманная архитектура поможет создавать языки как конструктор для нужных задач. Нельзя допустить роста множества DSL’ей, где один язык решает одну проблему, чтобы не пришлось каждый день учить новый инструмент, но база модулей помогла бы иметь гораздо более полезный эффект. Не хватает высокоуровневого программирования в системном языке? Подключите модуль с zero-cost абстракциями. Не хватает функционального программирования в ООП языке? Подключите модуль с синтаксическим сахаром, оператором |>, ленивыми вычислениями и unified calls.

В рейтинге языков программирования TIOBE Rust занимает 14 место. Для сравнения — в прошлом марте он был на 17 позиции. Вместе с экспертами Solvery Василием Кузенковым, full-stack разработчиком в Web3 стартапе, и Дмитрием Беляевым, Rust developer в Wildberries, разбираемся, как стать разрабом на Расте в 2025 году.

Немного об особенностях

Если вы до этого программировали на ООП языках, то вам, возможно, бросалось в глаза отсутствие привычных классов. Вместо них здесь алгебраические типы данных и трейты для решения expression problem. Их механизм куда больше похож на typeclasses из Haskell, что также будет для вас новой концепцией при построении крупных приложений, и нужно будет перестраивать мышление.

Также когда стартуешь, немного непривычно работать с move-семантикой, RAII, borrow checker’ом и лайф-таймами. Но компилятор сыпет довольно подробными ошибками, которые можно легко поправить, если разобраться.

А еще у Rust очень строгая типизация и очень мощная система типов, а сами типы построены так, чтобы предоставлять некоторые гарантии программисту. Например, ссылки в Rust всегда ссылаются на объект, гарантировано существующий в памяти, а стандартные строки содержат только валидный UTF-8. При этом в подавляющем большинстве случаев тип необязательно указывать явно, компилятор способен выводить типы, анализируя контекст функции целиком. Кроме того, Rust следует идеологии «компилируется, значит, работает». От логических ошибок, конечно, Раст не спасёт, но тем не менее очень большой пласт багов можно отловить на этапе кодинга. Да, это сложно, но лучше помучиться при разработке, чем потом разбираться почему упал прод.

Ещё одна отличительная фишка — абстракции с нулевой стоимостью. Rust позволяет писать высокоуровневый и понятный код, который при этом будет иметь ту же производительность, что и более низкоуровневый оптимизированный вручную вариант.

Хороший пример здесь — итерация по различным коллекциям. Многие языки позволяют использовать итераторы с их абстракциями вроде map или filter. Только такой код, как правило, будет в несколько раз медленнее, чем если то же самое переписать на циклы. Компилятор Rust способен развернуть такой итератор в обычные циклы сам, и производительность будет сравнима, а порой даже лучше, так как программисты часто при написании низкоуровневого кода заставляют процессор делать много лишних вычислений.

Сложно ли переходить на Rust

У Rust достаточно нетривиальная кривая входа, и без понимания некоторых важных принципов сложно написать код, который хотя бы будет компилироваться. Это относится не только к полным новичкам в программировании, но и к людям, которые уже владеют другим языком.

На рынке фактически все вакансии требуют уже какого-то опыта в разработке. И сложность перехода сильно разнится от вашего текущего стека. Для Go-программиста переход будет средне-сложным, а язык, возможно, покажется перегруженным. Для С++ — менее сложным, но язык покажется местами ограничивающим. Я переходил на него с JS/TS’а и столкнулся со множеством низкоуровневых концепций, о которых раньше мог не задумываться. Но если у вас есть опыт в системном программировании — переходить будет в разы проще.

Однако Rust прививает программисту очень много хороших привычек, которые меняют подход к написанию кода и на других языках. Это однозначно хороший выбор в качестве первого языка, но при условии, что у вас есть достаточно времени и терпения на освоение.

В моей практике менторства много успешных кейсов перехода на Rust с самых разных языков, но проще всего он даётся тем, кто раньше писал на современном C++ и уже понимает такие концепции, как move-семантика и RAII. Много привычного здесь обнаружат и те, кто писал на функциональных языках (Haskell или OCaml). Но в целом, для остальных тоже нет никаких проблем, даже если вы совсем новичок.

С чего начать изучать Rust

Вместе со стартом в изучении языка с The Rust Book — бесплатной официальной книгой по Rust’у — стоит углубить свои знания в более низкоуровневых вещах: в чем разница стека и кучи, что такое разметка памяти и адресация в памяти, как работает процессор, подходы и проблемы многопоточного программирования, плюс почитать про операционные системы и сети. Если вы решили осознанно применять Rust, оно вам пригодится.

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

Вот примерный список того, что нужно учить на старте:

• Переменные. Они по умолчанию неизменяемые (let x). Чтобы x стал изменяемым, нужно указать это явно через let mut. Константы (const) и статические переменные (static) вам будут нужны редко, они имеют свои особенности.
• Типы. Стоит разобраться с составными типами, такими как массивы и кортежи, а также с пользовательскими объявляемыми конструкциями struct (тип-произведение) и enum (тип-сумма). Также типы данных в Расте есть стандартные: bool, i32, u64 и прочие числовые, но строки могут удивить, так как их видов сильно больше.
• Match. Нужно понять такую вещь, как pattern-matching, познакомиться с оператором match, а также осознать, что pattern-matching применяется не только в нём, а везде, где возможно объявление переменных.

Таким образом, вы можете сразу проверить что-то и присвоить результат в переменную:

Здесь мы сразу проверили и присвоили:

Тут нам потребовалась дополнительная изменяемая переменная.

Что такое Cargo

Cargo — это консольная утилита, которая устанавливается вместе с компилятором языка. Она служит одновременно для управления зависимостями, сборки проекта и запуска тестов. Плюс для Cargo есть расширения, например, в поставке по умолчанию уже есть форматтер и линтер clippy.

Cargo рассчитан на то, что вы будете запускать его через терминал, самые полезные команды это:

• cargo new — создаёт новый шаблонный проект в указанной папке;
• cargo build — собирает проект;
• cargo run — собирает проект и запускает получившийся исполняемый файл;
• cargo check — dry-run сборки, делает все проверки компилятора, но ничего не собирает, что заметно быстрее полноценной сборки;
• cargo test — собирает проект со всеми тестами и запускает их;
• cargo fmt — форматирует проект в общепринятый стиль кода;
• cargo clippy — запускает линтер, очень полезно, можно подсказать более оптимальные варианты кода, найти некоторые потенциальные логические ошибки;
• cargo install — устанавливает пакет, содержащий исполняемые файлы;
• cargo clean — очищает все артефакты сборки.

Cargo позволяет описать структуру, настройки (профили сборки, описание крейта) и зависимости вашего крейта или даже монорепозитория (с помощью workspace). Кроме непосредственного запуска через терминал, многие вещи могут запускаться через средства интеграции в IDE, такие как rust-analyzer для VSCode.

Как работать с ownership, borrowing и lifetimes?

Для многих новичков системы владения (ownership), заимствования (borrowing) и времен жизни (lifetimes) выливаются в борьбу с компилятором раста. Эти механизмы нужны в первую очередь для безопасности памяти без сборщика мусора. Общее правило владения такое:

Каждое значение в Rust имеет переменную, которая называется его владельцем. В каждый момент времени может быть только один владелец. Когда владелец выходит из области видимости, значение уничтожается.

Когда значение перемещается (передается другой переменной или функции), владение переходит, и исходная переменная становится недействительной.

Для типов, реализующих трейт Copy (например, целые числа, булевы значения), значения копируются автоматически:

Для более сложных типов нужно использовать метод clone(), чтобы создать глубокую копию. В местах программы, где производительность не так важна — использование clone() не возбраняется.

Если же у вас критичный к производительности кусок кода, то вам также понадобится заимствоватние и лайфтаймы.

Заимствование позволяет использовать значение без получения владения через ссылки (& и &mut). Для мутабельных ссылок `&mut` есть дополнительные ограничения: в каждый момент времени может существовать только одна изменяемая ссылка на значение.

Нельзя иметь изменяемую ссылку, если уже есть неизменяемая ссылка на то же значение.

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

Аннотация 'a указывает, что возвращаемая ссылка будет жить как минимум столько же, сколько кратчайшая из входных ссылок.

Общие советы по заимствованию здесь такие:

• Используйте ссылки, когда не нужно владение.
• Возвращайте значения из функций для передачи владения обратно.
• Используйте клонирование для создания новых экземпляров (с пониманием стоимости).
• Используйте типы с трейтом Copy, когда это возможно.
• Еще полезно не забывать о контейнерах. Rc<T> позволяет иметь несколько владельцев одного значения через счетчик ссылок, а RefCell<T> обеспечивает проверку правил заимствования в рантайме.

О структурах, перечислениях, модулях и функциях, замыканиях, итераторах

Структуры (structs) в Rust позволяют создавать пользовательские типы данных, объединяющие связанные значения и выступающие типом произведения.

Перечисления (enum) позволяют определить тип, перечисляя все возможные варианты значений.

Перечисления в Rust являются типами суммы, поскольку значение может быть одним из вариантов:

Тип Shape представляет объединение (сумму) всех возможных вариантов. И к этому есть мощное сопоставление с образцом для работы с ADT:

Модули позволяют организовать код и контролировать видимость элементов. Определяются они через синтаксис mod <name> {} и могут быть вложенны друг в друга:

Также модули могут быть организованы в различных файлах (имя файла в таком случае будет именем модуля):

Импорт модуля осуществляется через ключевое слово use:

Функции в Rust определяются через ключевое слово fn:

Можно делать функции высшего порядка и передавать в них, как обычные, так и анонимные функции:

Еще одним элементом функционального программирования в Rust выступает итератор:

Здесь мы создаем собственный итератор Counter, реализуя стандартный трейт Iterator. Он используется для многих встроенных коллекций, таких как Vec или HashMap. Этот трейт особенно удобен из-за различных функциональных комбинаторов из стандартной библиотеки:

Трейт Iterator предоставляет множество методов адаптеров, таких как enumerate, filter или map, которые возвращают новый итератор. Методы адаптеров ленивые, они не запускают итерацию. Также есть методы исполнители, которые итерируют пока не закончатся значения, например, collect, fold или count.

Большинство коллекций (и ссылки на них) реализуют трейт IntoIterator (способность кастоваться в Iterator). Также IntoIterator автоматически реализуется для любого Iterator (ничего не стоящий каст сам в себя). Цикл for в Rust работает только с объектами, реализующими IntoIterator.

Как обрабатывать ошибки в Rust

В Rust принято разделять ошибки на 2 вида: паники и результаты операций:

• Паники используются для непредвиденных ситуаций и ошибок программиста, например, деление целочисленного типа на 0 или выход за границу массива. И хотя паники можно отловить, стандартное и рекомендуемое поведение при них — программа упадёт, будет напечатан стектрейс.
• Результаты операций выражаются типом Result<T, E>, который является перечислением из двух вариантов — Ok(T) и Err(E). Такой подход гарантирует, что все ошибки строго типизированы, а без обработки ошибки невозможно извлечь результат операции.

Option<T> используется для представления значения, которое может отсутствовать:

Result<T, E> используется для операций, которые могут завершиться ошибкой:

Для удобства проброса ошибок наверх существует оператор ?, который пишется после любого выражения, возвращающего Result, и возвращает Ok вариант. В случае Err варианта будет выход из функции с возвращением ошибки.

Обычно все ошибки описываются в перечислениях, а для уменьшения шаблонного кода используются крейты вроде thiserror.

Про асинхронное программирование

Асинхронное программирование в Rust строится вокруг трейта Future— его реализуют для типов, представляющих значение, которое будет доступно в будущем.

Также в Rust есть синтаксис async/await. Ключевым словом async могут быть отмечены функции и блоки кода — они будут возвращать анонимный тип, реализующий Future. Async-блоки также могут захватывать окружение подобно замыканиям. Внутри async-блоков и функций возможно использовать ключевое слово await на любом выражении, возвращающем Future или IntoFuture (способность кастоваться к Future). В отличие от других языков с подобным синтаксисом, await записывается через точку после выражения, что очень удобно для построения цепочек вычислений.

Для исполнения асинхронного кода необходим рантайм, но стандартная библиотека такого рантайма не предоставляет, поэтому приходится использовать сторонние библиотеки. Самым популярным рантаймом является библиотека tokio.

В асинхронное программирование на Rust я рекомендую приходить уже после углубленного изучения языка, первых пет-проектов и небольшой работы с многопоточным кодом. Хотя синтаксис и общие правила работы с асинхронным кодом покажутся знакомыми тем, кто знает JS или C#, из-за более низкоуровневой природы языка работать с ним немного сложнее.

Что еще должен знать новичок в Rust

Вот примерный список:

• Очень желательно погрузиться в устройство памяти процесса, узнать, что помимо стека и кучи существуют и другие области (например, исполняемый машинный код так же отражён на память, а static-переменные хранятся не в стеке и не в куче, а в своей собственной области). Неплохо было бы и разобраться с тем, что у типов помимо размера есть выравнивание. Что в Rust бывают ZST (zero size type) — типы, размер которых честный 0, и DST (dynamic size type) — типы, размер которых неизвестен во время компиляции.
• Обязательно разобраться, как Rust освобождает память, не используя сборщик мусора. Почитать, что такое RAII. Понять, как работает трейт Drop.
• Избавится от стереотипов о Rust. Rust — не самый сложный язык, как только вы поймёте, как он работает. Плюс платят за Rust, как правило, больше, чем на аналогичных позициях на других языках.
• Оставить свои привычки из других языков (за исключением разве что Haskell/OCaml). Здесь не получится писать, как на C++/Java/Go и т.д. Привыкайте к хорошему и станете лучше, чем были до освоения Rust.

Что изучать, если есть вся база: чек-лист

• Макросы и метапрограммирование
• Unsafe Rust для низкоуровневого контроля
• Интеграция с C/C++ через FFI
• Разработка встраиваемых систем
• WebAssembly
• rustnomicon
• Undefined Behavior
• unsafe-код

Тренды на 2025 год

На Rust’е пишут все. Более полный список можно посмотреть тут: https://github.com/rust-unofficial/awesome-rust

Вот несколько топовых фреймворков и библиотек:

• serde — фреймворк для сериализации/десериализации
• tokio, futures — для асинхронного программирования
• clap — парсер аргументов командной строки
• anyhow, thiserror — удобная работа с ошибками
• chrono — работа с датой и временем
• dashmap — многопоточная hashmap
• bytes — эффективная работа с сырыми байтами
• log, tracing — для логирования
• reqwest — для http запросов
• axum — для http сервера и REST api
• mockall, test-case — упростит написание тестов
• bevy — игры
• clippy — линтер

Это не мода, а стратегия: так вирусы проще скрываются от антивирусов и сложнее поддаются анализу.

Когда антивирус ищет угрозы, он часто использует статический анализ — проверку кода без запуска. Но если вирус написан на редком языке, инструменты просто не понимают, что с ним делать. Они не видят знакомых шаблонов и не могут оценить поведение — вирус остаётся незамеченным.

Чем реже язык — тем выше шансы обойти защиту

Классика вроде C и C++ всё ещё в ходу, но всё чаще встречаются варианты: Python, Go, Delphi, Rust. Например, группировка APT29 использовала Python, Go и даже смесь из Delphi и C#. Hive и Akira перешли на Rust, а BlackByte — на Go.

Такие языки часто компилируются нестандартно: код получается сложным и запутанным. Даже простой вирус на Go может выглядеть, как серьёзная программа с кучей функций. Это затрудняет проверку и делает автоматический анализ почти бесполезным.

Не только язык, но и компилятор играет роль

Авторы изучили почти 400 тыс вредоносных файлов и выяснили: важен не только язык, но и компилятор.

Инструменты вроде Delphi или Tiny C создают такой код, который антивирусы практически не узнают. Причина простая — слишком мало обучающих примеров, чтобы построить надёжные сигнатуры.

Даже если вирус делает то же самое, что на C++, его версия на Haskell может пройти мимо всех систем защиты — просто потому, что она выглядит иначе и не совпадает с известными шаблонами.

Вредоносы становятся всё разнообразнее

С каждым годом злоумышленники используют всё более необычные языки и технологии. Это усложняет жизнь аналитикам: чем реже встречается технология, тем сложнее её анализировать вручную, а автоматические системы почти бессильны.

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

Рекурсия: что это такое и зачем нужна

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

А теперь давайте разберемся на простом примере из математики: представим, что у нас есть функция F, которая выполняет определенное действие. В нашем случае — вычисляет факториал числа (это самый классический пример). Внутри этой функции F в качестве одного из значений используем вызов этой же функции F, но с уменьшенным аргументом. Так функция будет вызывать саму себя до тех пор, пока не достигнет базового случая (о нем расскажем ниже), после чего начнет возвращать результаты.

В виде кода это выглядит так:

Здесь функция F вычисляет факториал числа n, умножая его на факториал n-1, и так до тех пор, пока не дойдёт до 1, после чего начнёт возвращать результаты вверх по цепочке вызовов. Этот пример как раз о том, что нужно выполнить несколько одинаковых действий.

А вот пример из жизни: вы листаете ленту в известной социальной сети, а новые посты обновляются автоматически — это рекурсия в действии.

Принципы работы рекурсии

Рекурсия строится на двух ключевых принципах: базовый случай и рекурсивный вызов. Они позволяют функции вызывать саму себя, пока она не завершится.

Базовый случай

Базовый случай рекурсии — условие, при котором рекурсивный вызов прекращается. Без него функция будет вызывать саму себя бесконечно, а значит, стек переполнится.

Один из самых простых примеров — факториал, о котором мы писали выше. Другой — возведение числа в степень до тех пор, пока значение не станет равно искомому.

Так это выглядит в виде кода:

То есть, базовый случай — если exponent == 0, то возвращаем 1.

Рекурсивный вызов

Рекурсивный вызов — шаг, на котором функция вызывает саму себя, но с измененными параметрами, чтобы задача стала проще. Один из еще одних классических примеров — задача с числами Фибоначчи.

Числа Фибоначчи — это последовательность, где каждое число равно сумме двух предыдущих: 0, 1, 1, 2, 3, 5, 8, 13, 21, …

Если вызвать fibonacci(5), то увидите следующее:

После этого функция возвращает результаты обратно вверх по стеку вызовов. Обычно этот метод используется в криптографии и алгосах.

Кстати, на примере чисел Фибоначчи можно разобрать одну из проблем рекурсии — плохая производительность при отсутствии мемоизации.

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

Так, функция в задаче с числами Фибоначчи имеет экспоненциальную сложность O(2^n), так как она многократно вычисляет одни и те же значения. Например, чтобы вычислить fibonacci(5), функция вызывает сама себя 15 раз, хотя уникальных вычислений всего 6.

Чтобы улучшить производительность, нужно использовать мемоизацию, чтобы сохранить результаты:

Здесь сложность уменьшается до O(n), так как каждое значение вычисляется только один раз.

Стек вызовов и управление памятью

Каждый рекурсивный вызов функции добавляет новый элемент в стек вызовов. Это значит, что вызовы складывается в стеке до тех пор, пока не будет достигнут базовый случай. После этого стек начинает разворачиваться, возвращая результаты на каждом уровне.

Например:

Так, когда мы вызываем сountdows(3), в стеке появляются новые вызовы:

call countdown(3) # → печатает 3

call countdown(2) # → печатает 2

call countdown(1) # → печатает 1

call countdown(0) # → печатает "Старт" и выходит

Затем стек начинает разворачиваться:

• countdown(0) завершился → удаляется из стека
• countdown(1) завершился → удаляется из стека
• countdown(2) завершился → удаляется из стека
• countdown(3) завершился → удаляется из стека

Если же в рекурсии нет базового случая, то стек вызовов никогда не освободится, и программа (в нашем случае на Питоне) выдаст ошибку RecursionError.

Вот пример бесконечной рекурсии:

В Питоне есть ограничения до 1000 вызовов, чтобы не перегружать стек, но этот лимит можно увеличить:

Рекурсия на реальных задачах

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

Обход структуры данных

Рекурсия часто используется для обхода деревьев и графов. Например, бинарного дерева — в нем не более двух дочерних узлов (левый и правый). Вот три основных способа обхода:

1. Прямой обход (Pre-order): Корень → Левый узел → Правый узел.
2. Симметричный обход (In-order): Левый узел → Корень → Правый узел.
3. Обратный обход (Post-order): Левый узел → Правый узел → Корень.

Запишем в виде кода:

Дерево будет выглядеть так:

1

/ \

2 3

/ \

4 5

• Прямой обход: 1 → 2 → 4 → 5 → 3.
• Симметричный обход: 4 → 2 → 5 → 1 → 3.
• Обратный обход: 4 → 5 → 2 → 3 → 1.

Обходить можно и графы, особенно в глубине (DFS). Вот пример:

Сам граф:

Результат обхода: A → B → D → E → F → C.

Разбиение

Разбить можно массив или строку. Давайте разбираться на примере строки. Так, рекурсия может разбить строку на слова или разделить ее по конкретным символам. Выглядит это так:

Что такое хвостовая рекурсия

Хвостовая (оконечная) рекурсия — частный случай рекурсии. Главное отличие от обычной в том, что единственный рекурсивный вызов находится в конце перед выходом функции. В традиционной же рекурсии после рекурсивного вызова могут быть дополнительные вычисления.

Вот пример:

Кстати, с помощью хвостовой рекурсии тоже можно решать задачи с числами Фибоначчи:

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

Давайте посмотрим, как это работает в Scala. Вот обычная рекурсия, чтобы понять принцип:

А вот рекурсия с оптимизацией:

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

Это пример итеративного решения факториала.

Рекурсия vs. итерация

Основные различия между рекурсией и итерацией заключаются в следующем:

• В рекурсии функция вызывает саму себя, а в итерации используются циклы.
• Интеграция требует меньше памяти, потому что нет стека вызовов.
• Рекурсия медленнее без оптимизации.
• С рекурсией легко переполнить хранилище при большой глубине.
• Рекурсия обычно более читаемая и лаконичная, но подходит для меньшего количества задач.

Итерацию лучше использовать в следующих случаях:

• Задачи, где нужна производительность. Как, например, с итеративным вычислением чисел Фибоначчи.
• Обработка больших данных, например, поиск или сортировка. Вот пример пузырьковой сортировки:

• Задачи с большой глубиной рекурсии, чтобы стек не переполнялся. Вот как итеративно обойти дерево:

Еще один пример: задача «Ханойские башни»

«Ханойские башни» — классная головоломка, которую часто решают с помощью рекурсии. Считайте, что это еще одна классика.

Есть три стержня: A, B и C. На стержень A нанизано несколько дисков разного размера, причем диски упорядочены по размеру в виде пирамидки — вниз от маленького к большому. Суть в том, чтобы переместить все диски со стержня А на С, при этом: за один раз можно перемещать только один диск, нельзя класть больший диск на меньший, можно использовать стержень B как вспомогательный.

Рекурсивное решение задачи «Ханойские башни» основано на следующей идее:

1. Переместить (n−1) дисков с A на B, используя C как промежуточный.
2. Переместить оставшийся самый большой диск с A на C.
3. Переместить (n−1) дисков с B) на C, теперь используя A как промежуточный.

Следовательно, если количество дисков n=1, просто переместите его с А на С (базовый случай). В остальных случаях при n–1 повторить то, что указано выше.

А теперь решение с помощью кода:

Вывод:

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

В функциональных языках код проще тестировать, корректировать и поддерживать в рабочем состоянии. Функции в ФП — это объекты первого класса, которые передаются как аргументы, могут быть возвращены из других функций и храниться в переменных.

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

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

Этот материал представляет собой введение в функциональное программирование на языке Haskell. Расскажем об особенностях и преимуществах и как он применяется на практике.

Основные концепции ФП

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

Для начала краткая историческая справка. Предтечей Хаскела был другой функциональный язык — Миранда с концепцией «ленивых» вычислений. Финансовая поддержка этого языка была вполне солидной, но особой популярности он не снискал, так как распространялся по частной лицензии.

В качестве доступной альтернативы Миранде были созданы другие языки, среди которых наиболее популярным стал Haskell. Название язык получил в честь математика из США Хаскелла Карри, создателя комбинаторной логики.

В 1990 году опубликована первая версия, через 8 лет создатели представили стандарт The Haskell 98 Report. Эта версия до сих пор остается базовой, что не отменяет постоянного развития и совершенствования языка.

Основное преимущество функционального программирования на Haskell в открытом характере этого инструмента. Разработчики принимают от всех желающих предложения по улучшению и расширению функционала.

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

В программировании на Haskell собственно функция некоторого множества — основной структурный элемент кода. Задача разработчика — описать функцию так, чтобы автоматическому компилятору, который переводит текст в машинный код, были понятны все значимые моменты:

• какие параметры могут стать функцией;
• какие действия необходимо выполнить;
• как будет выглядеть итоговый код.

Несмотря на концептуальную сложность, Хаскелл входит в топ наиболее распространенных языков с поддержкой отложенных (они же ленивые) вычислений. Он имеет встроенную поддержку параллельного программирования и обширный инструментарий — это и средства автоматической проверки и отладки, и тысячи библиотек, созданных пользователями всего мира.

Характеристики Haskell

Прежде чем перейти к более узким темам, стоит рассмотреть наиболее важные характеристики Хаскелл:

Ленивость (отложенность)

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

Пример практического применения принципа ленивости — обычный калькулятор на сайте, в котором заложено множество функций, но в конкретный момент используются только нужные пользователю.

Преимущество такого принципа в том, что разработчик имеет возможность взаимодействовать с почти бесконечными структурами данных. Можно сравнить это с чтением научных статей, в которых есть формулы. Когда читатель доходит до таких мест, от может пропустить их и вернуться позже, как только будет готов сконцентрироваться.

При изучении Хаскелла действительно не так важно, если программист не совсем понимает некоторые моменты синтаксиса. Главное — это уловить общую идею кода.

Статическая типизация

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

Система типов в Haskell строгая и статичная. Это означает, что они имеют четкие различия, которые задаются еще на стадии компиляции, а не при исполнении программы.

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

Функциональность

Разработчикам, которые работали только с императивными языками, придется освоить множество новых концепций. Однако определенные сложности пойдут только на пользу программисту — он приобретет новые практические навыки. Эксперты утверждают, что после работы с Хаскелл становится проще кодировать на С++, Java и иных языках.

Чистота

Функциональный язык Haskell работает исключительно с чистыми функциями. Для них характерны такие свойства, как:

• строгая детерминированность — одному значению аргумента соответствует одно значение программной функции;
• отсутствие побочных действий — то есть влияния функции на среду исполнения.

Есть и исключения: для некоторых задач требуется как недетерминированность, так и побочные эффекты. Эти возможность реализованы посредством монад.

В целом здесь действует основной закон Хаскелла: использование функции с одинаковыми параметрами приводит к одному и тому же результату.

Модульность

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

Подобная структура существенно упрощает создание и тестирование программных продуктов. Если потребуется улучшить код или исправить ошибку, сделать это можно в отдельном модуле, не затрагивая всю программу. Модульность ускоряет разработку ПО, разделяя отдельные блоки между разными командами разработчиков.

Параметрический полиморфизм

В Хаскелле можно оперировать значениями разных типов одинаковым образом. Это свойство делает язык более выразительным и позволяет неоднократно пользоваться конкретным фрагментом кода для работы с различными данными, что значительно упрощает разработку ПО.

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

Преимущества и недостатки

Ключевые преимущества функционального языка Haskell:

• Слои языка четко подразделяются на «чистые» и «нечистые», поэтому разработчикам проще работать с каждым блоком по отдельности. Благодаря такому разделению код лучше понятен не только тем, кто с ним работал, но и сторонним программистам.
• Разделение кода на независимые блоки существенно упрощает тестирование продуктов. Находить и исправлять ошибки в независимых модулях проще, при этом не приходится переписывать весь код. Устойчивость программы к ошибкам повышается, поскольку они локализованы в отдельных модулях.
• Благодаря свободному доступу созданы тысячи инструкций, библиотек и рекомендаций для начинающих и опытных программеров на Хаскелл. Активное комьюнити профи и любителей поможет решить проблемы в процессе программирования — всегда можно запросить помощь или найти готовое решение.
• Поскольку типы назначаются и проверяются еще на стадии компиляции, этим не придется заниматься в процессе работы программы. Благодаря ленивости ПО не тратит ресурсы на вычисление функций, не задействованных в настоящий момент. Скорость реализации кода повышается, проще включать параллельное вычисление и работать в режиме многозадачности.
• Для Haskell создано множество разных инструментов проверки, отладки и интеграции с продуктами на других языках. По этой причине Хаскелл успешно применяется в практических целях, в том числе для работы с математическими задачами и для разработки утилитарных продуктов.

Эксперты отмечают и недостатки:

• Сложный синтаксис. Поначалу он может показаться нерациональным, особенно опытным разработчикам, привыкшим к языкам программирования со стандартным синтаксисом. Как ни странно, начинающим программистам освоить Haskell будет проще, поскольку у них нет конкретных предпочтений в парадигмах языков.
• Неравномерное развитие на разных платформах. Разработчики изначально ориентировались на Linux и MacOS, поэтому те, кто работает на Windows, сталкиваются с определенным дефицитом инструментов и прочими проблемами.
• Сложность в решении нестандартных задач. В репозиториях и библиотеках собрано множество решений, но значительная их часть посвящена работе с типовыми проблемами. Нестандартные задачи приходится решать самостоятельно либо просить помощи у сообщества.

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

Основы языка Haskell

Итак, чистая функция всегда показывает стабильный результат при одних и тех же вводных данных. Она не меняет состояния кода и не зависит от внешнего влияния. Такой код проще тестировать по причине его предсказуемости.

В примере функция add демонстрирует, что для одинаковых значений «x» и «у» итог всегда будет одинаковым. Эта особенность чистых функций чрезвычайно важна и полезна в ФП.

Неизменяемость данных (она же иммутабельность) означает, что созданные значения невозможно изменить, можно только ввести новые значения. Такое свойство исключает ошибки, связанные с изменением статуса, и делает код более предсказуемым.

В примере «x» не меняется, даже если создано новое значение «y». Такое свойство упрощает работу с кодом — можно не беспокоятся, что значения изменятся непредсказуемым образом.

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

В примере функция applyTwice принимает значение «x». Таким образом функция используется для разработки более мощных структур.

Процесс каррирования — это преобразование функции, принимающей ряд аргументов, в функцию, которая принимает один аргумент. Процедура повышает гибкость программных элементов.

Здесь функция «add» каррирована, что приводит к созданию другой функции «addFive», которая всегда прибавляет 5 к аргументу. Таким образом, функцию можно использовать в разных контекстах.

Лямбда-выражения и высшие функции

В написании кода на Haskell функции определяет команда «let», после чего следует указание имени, типа аргументов и тела функции.

В примере простая функция add, суммирующая два значения. На аналогичной основе создаются более сложные программы.

Итерации выполняются в Хаскелл с помощью рекурсивных функций, а не циклов, как в более привычных нам императивных языках.

В примере факториал вычисляется с помощью рекурсии.

К важным структурам языка относятся списки. Их применяют для отображения последовательностей с помощью различных функций.

Здесь список содержит числа, а функция используется для удвоения элементов. Операции со списками разработчикам стоит освоить в первую очередь.

Для кратковременных операций применяют анонимные лямбда-функции. С их помощью можно создавать функции без имени.

Простой пример применения лямбда-функции для суммирования двух чисел:

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

Практическое применение Haskell

В специальной литературе можно встретить утверждение, что Хаскелл — язык гениев и академиков. Это верно лишь отчасти. Первый функциональный язык действительно не прост для освоения, но лишь до того момента, пока вы пытаетесь понять его концепцию в рамках парадигмы императивных языков. Если подойти к нему непредвзято, понять Хаскелл будет гораздо проще.

Применение на практике Haskell — это разработка видео-серверов, обработка сложных массивов данных, другие многосоставные задачи.

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

Кроме того, на этом языке работают программы синтаксического разбора, редактирования текста, некоторые поисковые сервисы и программы по удалению спама и рекламы. Структура Haskell наиболее удобна для отображения грамматических и прочих правил самых сложных языков, включая русский.

Чтобы начать работу с Haskell, потребуется установить компилятор Glasgow Haskell Compiler с пакетным менеджером Stack — он упрощает сборку проектов.

После установки откройте терминал введите команду «ghci» для запуска интерактивной оболочки языка. Несколько простых выражений помогут убедиться, что система работает:

Интерактивная оболочка позволяет свободно работать с кодом и тестировать его. Для изучения языка ее применение обязательно.

Чтобы создавать проекты, понадобится менеджер Stack. Для запуска нового проекта введите «stack new my-project» — эта команда предоставит структуру и установит нужные зависимости.

Основной файл — это Main.hs. Его нужно открыть и добавить:

Эта простая программа узнает имя пользователя и приветствует его.

Для компиляции и запуска применяются команды:

Менеджер Stack — наиболее удобный инструмент для кодирования на Хаскелл.

Итоги

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

COBOL

COBOL (Common Business Oriented Language) появился в 1959 году благодаря Грейс Хоппер (ее еще называют «бабушкой Кобала»). Изначально он был императивным и процедурным, а с 2002 года стал объектно-ориентированным. Распространился он по инициативе Минобороны США, а затем стал широко использоваться в финансовых вычислениях.

«Использование Кобола калечит ум. Его преподавание, следовательно, должно рассматриваться как уголовное преступление» — Эдсгер Дейкстра

В какой-то степени Дейкстра прав — у Кобола действительно сложный и громоздкий синтаксис в отличие от менее «многословных» языков. Тем не менее он крут в задачах, с которыми не справляются другие технологии. Дело в том, что Кобол проводит десятичные вычисления не с плавающей, а с фиксированной точкой — не нужны сложные правила округления, как, например, на Java, и операции производятся быстрее. К тому же код будет одинаково работать на 8-битной и 64-битной архитектурах, поскольку COBOL может хранить переменные разных типов вне зависимости от компилятора и архитектуры системы.

Именно поэтому Кобол незаменим в денежных операциях. В США язык используют банки и система здравоохранения — транзакции через терминалы, торговля на бирже и зарплаты врачам проходят именно через него.

Вот пример «простенького» кода:

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

Lua

Lua — это скриптовый язык программирования с исходным кодом на C. Ближе всего он к JavaScript с такой же прототипной моделью ООП, но LUA более мощный и гибкий. Массивы, структуры, множества и остальные составные пользовательские типы данных реализуются с помощью таблиц, а механизмы ООП — через метатаблицы.

Изначально язык разрабатывался для промышленности, скорее, для конкретной нефтяной компании Petrobras. Сейчас же его используют для разработки массового ПО, например, для графического интерфейса Adobe Lightroom, и игр. Так, с помощью Луа можно легко закодить поведение NPC и других персонажей, под которых не придётся переписывать движок. Среди таких игр — Garry's Mod, Roblox, Stalker и даже World of Warcraft.

Вот пример кода из «Сталкера»:

Кстати, потренировать свои навыки Lua можно в игре Retro Gadgets. Рассказывали о ней в нашей статье.

F#

F Sharp — мультипарадигмальный язык, который поддерживает не только процедурное и объектно-ориентированное программирование, но еще и функциональное. Его разработали в Microsoft Research, а затем компания интегрировала среду разработки F# в Visual Studio 2010 и последующие версии.

У F Sharp лаконичный код с выводом типов. Он ориентирован на данные, параллельный ввод-вывод, параллельные вычисление и часто используется в научных исследованиях, анализе данных, машинном обучении и веб-разработке. К тому же он интегрируется с .NET платформами.

Язык действительно редкий и непопулярный, а специалистов, знающих его, в 100 раз меньше, чем С#-разработчиков. Однако в некоторых специфических задачах, связанных с Big Data и ML, «фаршик» может быть крайне полезен.

Вот пример кода:

R

Еще один язык для подсчета цифр и чисел — R был создан специально для статистического анализа данных. В общем, очередное машинное обучение и Big Data. Он появился в Оклендском университете взамен платному и недоступному большинству разработчиков языку S.

Сейчас популярность R начинает расти, и им пользуются многие крупные компании, например, Amazon, Deloitte, Accenture, Google и другие. Тем не менее синтаксис не похож на другие языки — это в первую очередь статистическая технология, поэтому начинающим разработчикам разобраться в нем будет непросто. Среди функций — объединение данных из таблиц, создание интерактивных графиков, статистическое тестирование. Кстати, на R можно написать и веб-приложение с помощью библиотеки Shiny.

Вот пример кода, который делает из двоичного кода десятичный:

Clojure

Clojure — это современный, динамичный и функциональный «диалект» языка Lisp на платформе Java. Появился в 2007 году благодаря Ричу Хики. Разработан как язык общего назначения — он сочетает доступность и интерактивную разработку языка сценариев с надежной инфраструктурой для многопоточного программирования. Clojure известен своей интерактивной средой REPL и мощной поддержкой параллельного программирования.

Одна из ключевых характеристик языка — функциональность, а это значит, что в нем особое внимание уделяется применению функций и неизменности данных. Он также предоставляет доступ к Java-фреймворкам и может компилироваться как с байт-кодом Java, так и с JavaScript — это полезно и для серверной, и для клиентской разработки.

Clojure используют в крупных банках, например, в Raiffeisen, а также в Netflix, Amazon, Apple и других гигантах. Так, в Apple с помощью него собирают данные и статистику.

Вот, например, код Hello, world на Conjure:

Haskell

Еще один чистый функциональный язык программирования. Среди особенностей — строгая типизация, почему он и назван в честь Хаскелла Карри, исследователя теории типов и создателя комбинаторной логики. Также язык поддерживает отложенные вычисления.

Haskell отличается не только простым и элегантным синтаксисом, но и быстротой и производительностью. Он применяется в инвестиционном банкинге, а также для создания системных продуктов и ПО. Разумеется, его тоже используют в крупных компаниях: в Meta*, IBM, Twitter, Bank of America и других. Например, Facebook* борется с помощью Haskell со спамом.

Очередной Hello World, только на Haskell:

Да, это все. putStrLn можно заменить на print.

Elixir

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

Среди особенностей — возможность метапрограммирования, которые позволяют разработчикам писать код, который сам пишет код, и поддержка параллельного программирования. Elixir также предоставляет мощные встроенные инструменты для тестирования и отладки программного обеспечения.

Язык широко используется в веб-разработке, особенно в среде Phoenix Framework, а также при создании распределенных и отказоустойчивых систем, благодаря базовой платформе Erlang/OTP. Для разработчиков, не знакомых с парадигмами функционального программирования, освоить будет не так просто, зато какие преимущества — эффективность, масштабируемость и надежность приложений.

Вот код, который продублирует строки множество раз:

На самом деле, нишевых и редких языков программирования очень много. И даже опытные разработчики могли никогда о них не слышать. Зато такие языки помогают решать специфические задачи, когда популярные решения бессильны.

Делитесь в комментариях, на каких редких языках ходили и как вам это помогло в разработке проекта.

*Компания Meta признана экстремистской и запрещена на территории РФ

Множество людей советовали мне изучить Haskell, Scala, Clojure, Erlang или Lisp, потому что они помогут хорошо понять функциональное программирование. Но я не уверен, за какой стоит взяться в первую очередь. У меня есть опыт работы с Python и JS, но я ни разу не сталкивался с функциональными языками программирования, поэтому также хочется знать, какие языки для чего используются: приложения, сайты, игры, машинное обучение и так далее.

В ответ HistoricalAccess9501 получил несколько дельных советов.

UdPropheticCatgirl

Я думаю, что любой из потомков и диалектов Lisp подойдет, например, SBCL или Clojure (и, возможно, Racket).

Можно взяться за Elixir, Erlang и Gleam, особенно чтобы разобраться в BEAM. Если вы хорошо знакомы с акторами и IPC. Scala великолепен, но многим отличается от большинства функциональных языков, поэтому не стоит учить его в первую очередь. Еще я бы не брался за Haskell и вместо него учил OCaml.

Что касается сфер применения:

• Scala используется для построения дата-пайплайнов, и для бэкенда на Java.
• Clojure — оптимальный Lisp, для работы в 2024, в основном если пишете бэкенд на Java.
• SBCL сегодня встречается редко, я сталкивался с ним только во время работы с HFT, еще в какой-то момент его часто использовали в сфере ИИ, но не уверен, продолжают ли сейчас.
• Elixir — снова бэкенд, особенно если работаете с распределенными системами.
• Erlang — король распределенных систем, часто используется в телекоме.
• Haskell подходит, только если вам не о чем поговорить с курьером и перед партией в D&D.
• OCaml используется примерно в двух финтех-компаниях и некоторыми небольшими анализаторами в Meta, вот и все.

VicariousAthlete

F# просто замечательный — мой лучший опыт в этой сфере. Сейчас мы используем его в создании масштабных систем (заказ еды онлайн).

nandryshak

Сначала определите, какие концепции вы хотите изучить, а потом подберите под нее язык. Не забудьте про популярность языка — хорошее сообщество и большой набор инструментов упростят обучение.

• Функции первого класса, составные функции и прочее? — Javascript, Racket.
• Все вышеперечисленное плюс неизменяемые объекты? — Clojure.
• Все вышеперечисленное плюс хорошая система типов? Typescript.
• Все вышеперечисленное плюс, Хиндли-Милнер и математика? — Haskell.

<…>

Joewoof

Сложно выбрать. Самый простой и популярный — Scala, но это мультипарадигмальный язык. Haskell слишком редкий. Что-то среднее?

Наверное, OCaml. Он преподается как первый в Кембридже, у него хорошая репутация. Если хотите что-то более практичное, то выбирайте Elixir.

0xAERG

Если вы знакомы с JS и хотите что-то похожее, советую попробовать изучить ReScript. Он функциональный, компилируется в JavaScript, а синтаксис похож на смесь OCalm и JS. <…>

davadds0

В университете я изучал Erlang и Scheme.

Рекомендую сначала изучить Erlang (сначала хорошо освоить vanilla Erlang), а затем — OTP, что-то вроде библиотеки/фреймворка Erlang, это спасет вас от монотонной работы. А еще будет удобно создавать сложные распределенные системы с помощью Erlang/OTP. <…>

Peiple

Из необычного — R, который полезен на практике. Он не такой хардкорный, как Haskell, но содержит большинство концепций функционального программирования. В основном используется в Data Science. <…>

Frenchslumbe

Самый легкий в освоении — Lips.

Простой и последовательный синтаксис (но при этом очень выразительный). К тому же, изучив Lips, будет проще с его диалектами и языками-потомками. <…>

Также советую ClojureScript. Это реализация Clojure, с компиляцией в JavaScript.

А что бы вы посоветовали, начинающим изучать функциональное программирование?

Вообще инструмент основан на модели GPT-2, предназначенной для обработки естественного языка. Но разработчики приспособили его и для понимания кода. К тому же, благодаря этому TabNine разбирается в документациях, а те как раз написаны на естественном английском.

TabNine совместим с VS Code, Sublime Text, Atom, Vim и прочими редакторами кода. Послать заявку на участие в бета-тестировании можно на сайте проекта.

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

Смотрите еще больше материалов по функциональному программированию.

Java

На Java Examples можно найти примеры на любой случай — от использования ключевых слов, вроде final, до объяснения, как выровнять иконку в Swing.

C#

Сайт для шарпистов С# Example вышел несколько более бедным, чем посвященный Java. Здесь вы не найдёте всех примеров, которые вам могут понадобиться, но можете найти что-то специфическое, например, как совместить несколько PrintDocument’ов.

JavaScript

Отдельный раздел JavaScript Book построен в форме самоучителя. Всего есть 13 тем, например: API, Error handling, jQuery, Events. Каждый из них содержит около десяти примеров. Правда, есть весомый минус — код выдаётся в виде текстового файла, без подсветки.

Haskell

Отличный способ изучить основы Haskell — ознакомиться с содержимым сайта Haskell By Examples. Здесь коротко описаны все базовые возможности языка, а примеры снабжены ссылками на Haskell Wiki.

Ruby

Существует и аналогичный ресурс по Ruby.

C++

Наверное, самый приятный сайт из этой подборки — это Cpp Examples. Красивый дизайн, подсветка кода, разнообразные сэмплы. Есть, несколько посвящённых паттернам, например, Observer или Builder.

PHP

Создатели русскоязычной подборки примеров с PHP.su сделали упор на практическое применение, а не на обучение новичков. Здесь не будет примеров, посвящённых ключевым словами и работе с переменными, но можно узнать, как сделать свою рассылку или гостевую книгу.

После продолжительного изучения Haskell я набрался достаточно опыта, чтобы сейчас дать вам пару советов. Кроме того, я хотел бы усвоить для себя кое-какие принципы, прежде чем идти дальше.
И хотя я иногда прибегаю к помощи Python, большую часть работы в вебе я теперь делаю на Haskell.

В первую очередь — данные

Я думал о переходе от динамического языка к статическому, а в Haskell’e структура данных, с которыми вы работаете, четко описывается при объявлении. В Python в большинстве случаев эту задачу выполняет код.

Когда я впервые увидел функции в Haskell, я задался вопросом: «Что представляют собой данные? Эта функция что-то берет на вход и выдает что-то на выходе?» А при работе с Python у меня возникал вопрос: «WHAT DOES THE CODE SAY?»

Структура данных Haskell сформировала качественно новый образ моего мышления, который я принес и в свою работу на Python. Мой код стал заметно лучше. И хотя очень часто мне казалось, что форма описанных мною данных менялась без причины, однако на деле все становилось ясно при небольшом изучении вопроса. Ограничения свободы в изменении данных также делают код менее сложным и более понятным.

Читаемость кода

Python привлекал меня возможностью писать действительно читаемый код. Примеры кода же на Haskell выглядели просто ужасно, за исключением некоторых сниппетов, которые, казалось, были подобраны специально, чтобы не напугать новичков. И хотя некоторые куски кода смотрелись очень даже приятно, большая часть исходников была наполнена чем-то страшным. А за этим «страшным» как раз и скрывалась вся мощь языка.

Я определенно не хотел писать «умный» код — тот, который способен продемонстрировать впечатляющие возможности языка, но совершенно неудобен.

Однако я оценивал читаемость языка Haskell в сравнении с другими популярными языками программирования. Это было похоже на то, как если бы я оценивал китайский язык, будучи носителем английского языка.

Я понял, что Haskell — это язык не «умный», но с хитринкой. Написать «умный» код на Haskell, конечно, можно, но это не распространенный случай. В то же время, мощь «умного» кода ограничена строгой типизацией. Если функция должна вернуть Int, она вернет Int. Ну или выкинет ошибку компиляции в крайнем случае.

А более мощные абстракции в Haskell и вовсе напоминают некую магию, которой я пытался избегать при работе с Python.

Про читаемость я говорю серьезно

Сначала поверьте и убедите себя, что, да, люди действительно читают листинги на этом новом для вас языке, причем делают это быстро и регулярно. Разобравшись наконец с большей частью известных нюансов, я начал спокойнее относиться к коду на Haskell.

Комментарии. Они занимают верхнюю строчку в одной из глав нашей «книги».

Эта глава описывает то, как Томми пошел в магазин и купил утку.

Функции из другой, уменьшенной функции, в общей картине сокращают код по максимуму.

Краткость. Вам не потребуется тонна кода для воплощения ваших идей.

Вставные символы

Я также хотел упомянуть о вставных функциях, которые распространены в языке Haskell. Вставные функции (или операторы) — это те функции, которые используют between для двух аргументов вместо before. Простым примером является «+».

В языке Haskell мы имеем несколько вставных символов, которые используются по умолчанию: $, <$>, <-, ->, др. Они могут вас немного смутить на начале пути.

Не переживайте! Как только вы научитесь применять их, вы поймете, как они полезны и просты. Я насчитал около 5 символов, которые я использую регулярно.

Я не советую сразу пользоваться библиотекой lens, так как она содержит тонну таких символов. Данная библиотека очень полезна, но поначалу вы сможете добиться больших успехов и без нее. Дождитесь того момента, когда вы сможете спокойно писать программы средней сложности на Haskell, затем начните использовать lens.

Нужно полностью обновить знания

При изучении Haskell вы будете попутно сталкиваться с новыми терминами, например, функтор или монада.

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

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

Моя стратегия по изучению таких слов пришла ко мне в голову совсем недавно, и я начал использовать ее каждый раз, когда видел непонятный мне термин. Она заключается в подборе синонимов к тем словам, которые вам не понятны и незнакомы. Спустя некоторое время, я научился подбирать эти синонимы.

Например, функтор.

В языке Haskell многое отображается на вашем экране. Например, список — это и есть функтор. Это значит, что отображающая функция, которая использует другую функцию, и выводится в списке. Затем создается новый список с результатами.

Так я дал название этому — мапа. Слово «мапа» является очень простым для запоминания. Список — это функтор. Список — это мапа.

Моя система проверки ошибок

Когда я писал на Python, моим инструментом отладки были операторы печати.

В Haskell я пользовался систематическими инструментами.

Но! Вы можете применить Debug.Trace. Данный прием схож с тем, как в Python функция печати не зависит от Haskell IO. И данный модуль может вначале принести пользу . Когда вы только начинали работать с Haskell, вы думали о том, как много вы будете его использовать?

Если вы не будете использовать операторы трассировки в вашем коде после проверки ошибок, то вы сразу заметите, что ваш код в Haskell выглядит хуже, чем в Python.

Лучший учебник по монадам

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

Я должен провести синтаксический анализ. Я кое-что знал об этом, когда писал на Python. Но, в силу моей неопытности в этой области, сейчас сделать анализ достаточно сложно.

Окей, сейчас я расскажу подробнее. Я буду объяснять на Haskell.

Я нашел видео на YouTube, «Parsing Stuff in Haskell», в котором описывалось, как сделать JSON анализ в Haskell, используя при этом библиотеку Parsec.

Это видео помогло мне ненароком понять, как можно, используя монады и аппликативные функторы, создать то, что мне требовалось. Я понял, как их функции (har, har) соединяются друг с другом.

После написания синтаксического анализа при помощи видео, я начал понимать весь код. Я также начал понимать всю его «природу». Но на начальном этапе это не пригодится.

Итак, Parsec делает свое дело достаточно неплохо, так что моя неопытность при написании анализа практически не заметна. Так же, как и любой другой начинающий в Haskell, я с лёгкостью мог даже в начале знакомства с этим языком делать неплохие программы и операции.

Польза от ваших знаний

Haskell является моим основным языком по нескольким причинам:

1. Выбор технологий, которыми я буду пользоваться.
2. Я могу писать свои программы быстрее, и чаще всего эти программы я и продаю.
3. Не приходится иметь дело с мелкими багами.
4. Даже сталкиваясь с несколькими ошибками, я быстро решаю их, так как они более-менее понятны.
5. Python не делал акцент на скорости работы. Haskell делает то же самое, но выбор все же за мной.
6. Рефакторинг, по сути, достаточно «ветреный». В Python я иногда сильно ругал себя, когда забывал править небольшие ошибки в коде, которые позже вызывали огромные затруднения.
7. Замечательные библиотеки. Основная особенность Haskell заключается в высоком качестве библиотек.
8. Сообщество, всегда готовое помочь.
9. Простота масштабирования кода до нужного ядра.
10. Haskell часто обновляется. В прошлом году, когда GHC (компилятор для Haskell) был обновлен до версии 7.8, делая при этом написание кода в два раза удобнее, были ускорены многие веб-сервера.

И в заключение хочу сказать, что Haskell доставил мне уйму удовольствия. Это был лучший опыт за всю мою жизнь.

С чего можно начать?

Я постарался и нашел много «отправных точек» для начала вашего знакомства с Haskell.

Здесь я продемонстрирую то, как бы я начинал, если бы был не знаком с Haskell.

Для начала, прочитайте статью «Learn you a Haskell for Great Good».

Отлично! Теперь выполните следующие пункты:

1. Напишите маленький модуль, при этом не используя IO. Что-то на примере судоку, в котором происходит генерация пазлов. Используйте рандомные числа для начала. Используйте Debug. Используйте оператор печати, чтобы видеть каждый ваш шаг. Сделайте генерацию пазлов и Debug’а. Отправьте все на экран. Создайте свой собственный тип файлов и используйте функции.
2. Закиньте все на сайт. Для этого используйте Scotty или Spock. Вот и все, ваш URL готов. Затем, URL, создающий JSON в вашем пазле.
3. Повозитесь с IO. Попробуйте написать пазл в терминале, не пользуясь Debug.Trace.
4. Находите новые варианты. Измените формат файла для пазла судоку и напишите синтаксический анализ Parsec для него! Не делайте формат JSON — попробуйте что-то новое.

Удачи!