Добро пожаловать в руководство пользователя GHC

Содержание:

• 1. Введение
  • 1.1. Получение GHC
  • 1.2. Дополнительная информация: веб-сайты, списки рассылки и т. д.
  • 1.3. Сообщение об ошибках в GHC
  • 1.4. Политика нумерации версий GHC
  • 1.5. Лицензия компилятора Glasgow Haskell
• 2. Примечания к выпуску
  • 2.1. Версия 9.14.1
    • 2.1.1. Язык
    • 2.1.2. Компилятор
    • 2.1.3. GHCi
    • 2.1.4. Бэкенд WebAssembly
    • 2.1.5. Система времени выполнения
    • 2.1.6. Библиотека base
    • 2.1.7. Библиотека ghc-prim
    • 2.1.8. Библиотека ghc
    • 2.1.9. Библиотека ghc-heap
    • 2.1.10. Библиотека ghc-internal
    • 2.1.11. Библиотека ghc-experimental
    • 2.1.12. Библиотека template-haskell
    • 2.1.13. Включённые библиотеки
• 3. Использование GHCi
  • 3.1. Введение в GHCi
  • 3.2. Загрузка исходных файлов
    • 3.2.1. Модули и имена файлов
    • 3.2.2. Внесение изменений и повторная компиляция
  • 3.3. Загрузка скомпилированного кода
  • 3.4. Интерактивное вычисление в командной строке
    • 3.4.1. Действия ввода-вывода в командной строке
    • 3.4.2. Использование нотации do в командной строке
    • 3.4.3. Многострочный ввод
    • 3.4.4. Объявления типов, классов и другие объявления
    • 3.4.5. Что на самом деле находится в области видимости в командной строке?
      • 3.4.5.1. Влияние :load на содержимое области видимости
      • 3.4.5.2. Управление содержимым области видимости с помощью import
      • 3.4.5.3. Управление содержимым области видимости с помощью команды :module
      • 3.4.5.4. Квалифицированные имена
      • 3.4.5.5. :module и :load
      • 3.4.5.6. Затенение и имя модуля Ghci1
    • 3.4.6. Переменная it
    • 3.4.7. Вывод типов по умолчанию в GHCi
      • 3.4.7.1. Интерактивные классы
      • 3.4.7.2. Расширенные правила для объявлений default
    • 3.4.8. Использование пользовательской функции интерактивного вывода
    • 3.4.9. Трассировки стека в GHCi
  • 3.5. Отладчик GHCi
    • 3.5.1. Точки останова и просмотр переменных
      • 3.5.1.1. Установка точек останова
      • 3.5.1.2. Управление точками останова
    • 3.5.2. Пошаговое выполнение
    • 3.5.3. Вложенные точки останова
    • 3.5.4. Переменная _result
    • 3.5.5. Трассировка и история
    • 3.5.6. Отладка исключений
    • 3.5.7. Пример: просмотр функций
    • 3.5.8. Ограничения
  • 3.6. Запуск GHCi
    • 3.6.1. Пакеты
    • 3.6.2. Дополнительные библиотеки
  • 3.7. Команды GHCi
  • 3.8. Команды :set и :seti
    • 3.8.1. Параметры GHCi
    • 3.8.2. Установка параметров командной строки GHC в GHCi
    • 3.8.3. Установка параметров только для интерактивного вычисления
  • 3.9. Файлы .ghci и .haskeline
    • 3.9.1. Файлы .ghci
    • 3.9.2. Файл .haskeline
  • 3.10. Компиляция в объектный код в GHCi
  • 3.11. Запуск интерпретатора в отдельном процессе
    • 3.11.1. Сборка внешнего интерпретатора
    • 3.11.2. Запуск интерпретатора на другом хосте
  • 3.12. Сборка библиотек GHCi
  • 3.13. Часто задаваемые вопросы и возможные проблемы
• 4. Использование runghc
  • 4.1. Использование
  • 4.2. Флаги runghc
  • 4.3. Флаги GHC

• 5. Использование GHC
  • 5.1. Использование GHC
    • 5.1.1. Начало работы: компиляция программ
    • 5.1.2. Обзор параметров
      • 5.1.2.1. Аргументы командной строки
      • 5.1.2.2. Параметры командной строки в исходных файлах
      • 5.1.2.3. Настройка параметров в GHCi
    • 5.1.3. Динамические параметры и параметры режима
    • 5.1.4. Значимые суффиксы файлов
    • 5.1.5. Режимы работы
      • 5.1.5.1. Использование ghc --make
      • 5.1.5.2. Протокол GHC Jobserver
      • 5.1.5.3. Несколько домашних единиц
      • 5.1.5.4. Режим вычисления выражений
      • 5.1.5.5. Режим пакетного компилятора
    • 5.1.6. Параметры подробности вывода
    • 5.1.7. Платформозависимые флаги
    • 5.1.8. Haddock
    • 5.1.9. Различные флаги
      • 5.1.9.1. Другие переменные окружения
  • 5.2. Предупреждения и проверки корректности
    • 5.2.1. Группы предупреждений
    • 5.2.2. Обработка предупреждений как критических ошибок
    • 5.2.3. Отдельные параметры предупреждений
  • 5.3. Оптимизация (улучшение кода)
    • 5.3.1. -O*: удобные «наборы» флагов оптимизации.
    • 5.3.2. -f*: платформонезависимые флаги
  • 5.4. Использование параллельного Haskell
  • 5.5. Использование параллелизма SMP
    • 5.5.1. Параметры параллелизма SMP на этапе компиляции
    • 5.5.2. Параметры RTS для параллелизма SMP
    • 5.5.3. Рекомендации по использованию параллелизма SMP
  • 5.6. Справочник по флагам
    • 5.6.1. Параметры подробности вывода
    • 5.6.2. Альтернативные режимы работы
    • 5.6.3. Выбор этапов выполнения
    • 5.6.4. Перенаправление вывода
    • 5.6.5. Сохранение промежуточных файлов
    • 5.6.6. Временные файлы
    • 5.6.7. Поиск импортов
    • 5.6.8. Параметры файлов интерфейсов
    • 5.6.9. Параметры расширенных файлов интерфейсов
    • 5.6.10. Проверка необходимости повторной компиляции
    • 5.6.11. Параметры интерактивного режима
    • 5.6.12. Пакеты
    • 5.6.13. Параметры языка
    • 5.6.14. Предупреждения
    • 5.6.15. Уровни оптимизации
    • 5.6.16. Отдельные оптимизации
    • 5.6.17. Параметры профилирования
    • 5.6.18. Параметры покрытия программы
    • 5.6.19. Параметры препроцессора C
    • 5.6.20. Параметры генерации кода
    • 5.6.21. Параметры компоновки
    • 5.6.22. Параметры плагинов
    • 5.6.23. Замена этапов
    • 5.6.24. Принудительная передача параметров определённым этапам
    • 5.6.25. Платформозависимые параметры
    • 5.6.26. Параметры отладки компилятора
    • 5.6.27. Различные параметры компилятора
  • 5.7. Параметры системы времени выполнения (RTS)
    • 5.7.1. Настройка параметров RTS
      • 5.7.1.1. Настройка параметров RTS в командной строке
      • 5.7.1.2. Настройка параметров RTS на этапе компиляции
      • 5.7.1.3. Настройка параметров RTS с помощью переменной окружения GHCRTS
      • 5.7.1.4. «Перехватчики» для изменения поведения RTS
    • 5.7.2. Различные параметры RTS
    • 5.7.3. Параметры RTS для управления сборщиком мусора
    • 5.7.4. Параметры RTS для вывода статистики времени выполнения
    • 5.7.5. Параметры RTS для конкурентности и параллелизма
    • 5.7.6. Параметры RTS для профилирования
    • 5.7.7. Трассировка
    • 5.7.8. Параметры RTS для покрытия программ на Haskell
    • 5.7.9. Параметры RTS для хакеров, отладчиков и чрезмерно любознательных
    • 5.7.10. Получение информации о RTS
  • 5.8. Имена файлов и раздельная компиляция
    • 5.8.1. Исходные файлы Haskell
    • 5.8.2. Выходные файлы
    • 5.8.3. Путь поиска
    • 5.8.4. Перенаправление вывода компиляции
    • 5.8.5. Сохранение промежуточных файлов
    • 5.8.6. Перенаправление временных файлов
    • 5.8.7. Другие параметры, относящиеся к файлам интерфейсов
    • 5.8.8. Параметры, относящиеся к расширенным файлам интерфейсов
    • 5.8.9. Проверка необходимости повторной компиляции
      • 5.8.9.1. Повторная компиляция для Template Haskell и плагинов
    • 5.8.10. Взаимно рекурсивные модули и файлы hs-boot
    • 5.8.11. Сигнатуры модулей
    • 5.8.12. Использование make
    • 5.8.13. Генерация зависимостей
    • 5.8.14. Модули-сироты и объявления экземпляров
  • 5.9. Пакеты
    • 5.9.1. Использование пакетов
    • 5.9.2. Пакет main
    • 5.9.3. Последствия использования пакетов для языка Haskell
    • 5.9.4. Сокращение и переименование модулей
    • 5.9.5. Базы данных пакетов
      • 5.9.5.1. Переменная окружения GHC_PACKAGE_PATH
      • 5.9.5.2. Окружения пакетов
    • 5.9.6. Идентификаторы установленных пакетов, зависимости и неисправные пакеты
    • 5.9.7. Управление пакетами (команда ghc-pkg)
    • 5.9.8. Сборка пакета из исходного кода Haskell
    • 5.9.9. InstalledPackageInfo: спецификация пакета
    • 5.9.10. Компоновка с библиотеками C++
  • 5.10. Бэкенды GHC
    • 5.10.1. Генератор машинного кода (-fasm)
    • 5.10.2. Генератор кода LLVM (-fllvm)
    • 5.10.3. Генератор кода C (-fvia-C)
    • 5.10.4. Генератор кода JavaScript
    • 5.10.5. Компиляция без выделения регистров
  • 5.11. Параметры, относящиеся к отдельным этапам
    • 5.11.1. Замена программы для одного или нескольких этапов
    • 5.11.2. Принудительная передача параметров определённому этапу
    • 5.11.3. Параметры, влияющие на препроцессор C
      • 5.11.3.1. Стандартные макросы CPP
      • 5.11.3.2. CPP и пропуски в строках
    • 5.11.4. Параметры, влияющие на препроцессор Haskell
    • 5.11.5. Параметры, влияющие на генерацию кода
    • 5.11.6. Параметры, влияющие на компоновку
  • 5.12. Использование динамических библиотек
    • 5.12.1. Сборка программ, использующих динамические библиотеки
    • 5.12.2. Динамические библиотеки для пакетов Haskell
    • 5.12.3. Динамические библиотеки, экспортирующие API C
    • 5.12.4. Поиск динамических библиотек во время выполнения
      • 5.12.4.1. Unix
      • 5.12.4.2. Mac OS X
  • 5.13. Отладка компилятора
    • 5.13.1. Вывод промежуточных структур компилятора
      • 5.13.1.1. Фронтенд
      • 5.13.1.2. Проверка типов и переименование
      • 5.13.1.3. Представление Core и упрощение
      • 5.13.1.4. Представление STG
      • 5.13.1.5. Представление C-\-
      • 5.13.1.6. Генератор кода LLVM
      • 5.13.1.7. Генератор кода C
      • 5.13.1.8. Генератор машинного кода
      • 5.13.1.9. Генератор кода JavaScript
      • 5.13.1.10. Различные дампы бэкенда
    • 5.13.2. Форматирование дампов
    • 5.13.3. Подавление ненужной информации
    • 5.13.4. Проверка согласованности
    • 5.13.5. Проверка детерминированности
    • 5.13.6. Прочее

• 6. Расширения языка
  • 6.1. Введение
    • 6.1.1. Управление редакциями и расширениями
    • 6.1.2. Обзор всех языковых расширений
    • 6.1.3. Краткий обзор заимствованного синтаксиса
  • 6.2. Синтаксис
    • 6.2.1. Синтаксис Unicode
    • 6.2.2. Магический символ решётки
    • 6.2.3. Рекурсивная do-нотация
      • 6.2.3.1. Рекурсивные группы связывания
      • 6.2.3.2. Нотация mdo
    • 6.2.4. Аппликативная do-нотация
      • 6.2.4.1. Строгие шаблоны
      • 6.2.4.2. На что следует обратить внимание
    • 6.2.5. Квалифицированная do-нотация
      • 6.2.5.1. Примеры
    • 6.2.6. Параллельные списковые включения
    • 6.2.7. Обобщённые (подобные SQL) списковые включения
    • 6.2.8. Монадические включения
    • 6.2.9. Перегруженные списки
      • 6.2.9.1. Класс IsList
      • 6.2.9.2. Переназначаемый синтаксис
      • 6.2.9.3. Выбор типа по умолчанию
      • 6.2.9.4. Размышления о будущем
    • 6.2.10. Переназначаемый синтаксис и неявный импорт Prelude
      • 6.2.10.1. Пользовательские модули Prelude с именем Prelude
      • 6.2.10.2. Элементы, на которые RebindableSyntax не влияет
    • 6.2.11. Постфиксные операторы
    • 6.2.12. Секции кортежей
    • 6.2.13. Lambda-case
    • 6.2.14. Пустые альтернативы case
    • 6.2.15. Многоветвевые if-выражения
    • 6.2.16. Do, And, If, Then, Else
    • 6.2.17. Локальные объявления фиксированности
    • 6.2.18. Более свободный синтаксис аргументов функций
      • 6.2.18.1. Изменения грамматики
    • 6.2.19. Типизированные дыры
      • 6.2.19.1. Допустимые подстановки в дыры
    • 6.2.20. Нотация стрелок
      • 6.2.20.1. do-нотация для команд
      • 6.2.20.2. Условные команды
      • 6.2.20.3. Определение собственных управляющих конструкций
      • 6.2.20.4. Примитивные конструкции
      • 6.2.20.5. Отличия от статьи
      • 6.2.20.6. Переносимость
    • 6.2.21. Лексическое отрицание
  • 6.3. Импорт и экспорт
    • 6.3.1. Сокрытие элементов, не экспортируемых импортированным модулем
    • 6.3.2. Импорты с указанием пакета
    • 6.3.3. Безопасные импорты
    • 6.3.4. Явные пространства имён в импорте/экспорте
      • 6.3.4.1. Ключевое слово type в списках импорта/экспорта
      • 6.3.4.2. Ключевое слово data в списках импорта/экспорта
      • 6.3.4.3. Явные пространства имён в объявлениях фиксированности и прагмах предупреждений/устаревания
      • 6.3.4.4. Ключевое слово type в выражениях и шаблонах
    • 6.3.5. Запись qualified в постпозитивной позиции
  • 6.4. Типы
    • 6.4.1. Типы данных без конструкторов
    • 6.4.2. Контексты типов данных
    • 6.4.3. Инфиксные конструкторы типов, классы и переменные типов
    • 6.4.4. Операторы типов
    • 6.4.5. Ослабленные синонимы типов
    • 6.4.6. Выбор типа переменной по умолчанию
      • 6.4.6.1. Выбор типа по умолчанию для классов типов
      • 6.4.6.2. Расширения выбора типа по умолчанию для классов типов
      • 6.4.6.3. Другие механизмы выбора значения по умолчанию
    • 6.4.7. Экзистенциально квантифицированные конструкторы данных
      • 6.4.7.1. Зачем нужны экзистенциальные типы?
      • 6.4.7.2. Экзистенциальные типы и классы типов
      • 6.4.7.3. Конструкторы записей
      • 6.4.7.4. Ограничения
    • 6.4.8. Объявление типов данных с явными сигнатурами конструкторов
      • 6.4.8.1. Формальный синтаксис GADT
      • 6.4.8.2. Прочие особенности синтаксиса GADT
    • 6.4.9. Обобщённые алгебраические типы данных (GADT)
    • 6.4.10. Семейства типов
      • 6.4.10.1. Семейства данных
      • 6.4.10.2. Семейства синонимов
      • 6.4.10.3. Шаблонные символы в левой части экземпляров семейств данных и типов
      • 6.4.10.4. Связанные семейства данных и типов
      • 6.4.10.5. Импорт и экспорт
      • 6.4.10.6. Семейства типов и объявления экземпляров
      • 6.4.10.7. Инъективные семейства типов
    • 6.4.11. Продвижение типов данных
      • 6.4.11.1. Мотивация
      • 6.4.11.2. Обзор
      • 6.4.11.3. Различение типов и конструкторов
      • 6.4.11.4. Литералы на уровне типов
      • 6.4.11.5. Продвинутые типы списков и кортежей
      • 6.4.11.6. Продвижение экзистенциальных конструкторов данных
      • 6.4.11.7. DataKinds и синонимы типов
    • 6.4.12. Особый синтаксис для списков и кортежей на уровне типов
    • 6.4.13. Объявления данных на уровне типов
    • 6.4.14. Полиморфизм по роду
      • 6.4.14.1. Обзор полиморфизма по роду
      • 6.4.14.2. Обзор Type-in-Type
      • 6.4.14.3. Принципы вывода рода
      • 6.4.14.4. Вывод рода в сигнатурах типов
      • 6.4.14.5. Явная квантификация по роду
      • 6.4.14.6. Вывод порядка переменных в объявлении типа/класса
      • 6.4.14.7. Полные пользовательские сигнатуры рода и полиморфная рекурсия
      • 6.4.14.8. Отдельные сигнатуры рода и полиморфная рекурсия
      • 6.4.14.9. Отдельные сигнатуры рода и заголовки объявлений
      • 6.4.14.10. Вывод рода в объявлениях типов данных
      • 6.4.14.11. Вывод рода в объявлениях экземпляров data/newtype
      • 6.4.14.12. Вывод рода в объявлениях экземпляров классов
      • 6.4.14.13. Вывод рода в синонимах типов и экземплярах семейств типов
      • 6.4.14.14. Вывод рода в закрытых семействах типов
      • 6.4.14.15. Роды высших рангов
      • 6.4.14.16. Род Type
      • 6.4.14.17. Вывод зависимостей в объявлениях типов данных
      • 6.4.14.18. Вывод зависимостей в пользовательских forall
      • 6.4.14.19. Выбор рода по умолчанию без PolyKinds
      • 6.4.14.20. Форматированный вывод при наличии полиморфизма по роду
      • 6.4.14.21. Возвращаемые роды типов данных
    • 6.4.15. Полиморфизм представления
      • 6.4.15.1. Полиморфизм по уровню представления
      • 6.4.15.2. Переменные и аргументы с полиморфным представлением не допускаются
      • 6.4.15.3. Значения bottom с полиморфным представлением
      • 6.4.15.4. Вывод и выбор значения по умолчанию
      • 6.4.15.5. Вывод типов с полиморфным представлением
    • 6.4.16. Литералы на уровне типов
      • 6.4.16.1. Значения времени выполнения для литералов на уровне типов
      • 6.4.16.2. Вычисления с натуральными числами на уровне типов
    • 6.4.17. Видимое применение типов
      • 6.4.17.1. Выводимые и заданные переменные типов
      • 6.4.17.2. Порядок заданных переменных
      • 6.4.17.3. Ручное определение выводимых переменных
    • 6.4.18. Абстракции типов
      • 6.4.18.1. Абстракции типов в шаблонах
      • 6.4.18.2. Абстракции типов в функциях
      • 6.4.18.3. Невидимые связыватели в объявлениях типов
      • 6.4.18.4. Связыватели-шаблоны в объявлениях типов
    • 6.4.19. Обязательные аргументы типов
      • 6.4.19.1. Терминология: зависимый квантор
      • 6.4.19.2. Терминология: видимый квантор
      • 6.4.19.3. Связь с TypeApplications
      • 6.4.19.4. Связь с ExplicitNamespaces
      • 6.4.19.5. Типы в термах
      • 6.4.19.6. Влияние на неявную квантификацию
      • 6.4.19.7. Связь с Π-типами
      • 6.4.19.8. Видимый forall в GADT
    • 6.4.20. Полиморфизм произвольного ранга
      • 6.4.20.1. Примеры
      • 6.4.20.2. Подчинение типов
      • 6.4.20.3. Вывод типов
      • 6.4.20.4. Неявная квантификация
    • 6.4.21. Импредикативный полиморфизм
    • 6.4.22. Линейные типы
      • 6.4.22.1. Выражения
      • 6.4.22.2. Типы данных
      • 6.4.22.3. Вывод типов с полиморфизмом по кратности
      • 6.4.22.4. Ограничения
      • 6.4.22.5. Проектирование и дополнительная литература
    • 6.4.23. Пользовательские ошибки времени компиляции
    • 6.4.24. Перенос ошибок типов на время выполнения
      • 6.4.24.1. Включение отложенных ошибок типов
      • 6.4.24.2. Отложенные ошибки типов в GHCi
      • 6.4.24.3. Ограничения отложенных ошибок типов
    • 6.4.25. Роли
      • 6.4.25.1. Номинальная, репрезентативная и фантомная роли
      • 6.4.25.2. Вывод ролей
      • 6.4.25.3. Аннотации ролей
  • 6.5. Записи
    • 6.5.1. Разрешение имён полей записи
    • 6.5.2. Традиционный синтаксис записей
    • 6.5.3. Селекторы полей и TypeApplications
      • 6.5.3.1. Селекторы полей для конструкторов данных в стиле Haskell98
      • 6.5.3.2. Селекторы полей для конструкторов GADT
      • 6.5.3.3. Селекторы полей для синонимов шаблонов
    • 6.5.4. Разрешение неоднозначности полей записей
    • 6.5.5. Повторяющиеся поля записей
      • 6.5.5.1. Импорт и экспорт полей записей
    • 6.5.6. Селекторы полей
      • 6.5.6.1. Импорт и экспорт функций-селекторов
    • 6.5.7. Сокращённая запись полей
    • 6.5.8. Шаблонные поля записей
    • 6.5.9. Полиморфизм селекторов полей записей
      • 6.5.9.1. Решение ограничений HasField
      • 6.5.9.2. Виртуальные поля записей
    • 6.5.10. Перегруженная точечная нотация записей
    • 6.5.11. Перегруженное обновление записей

• • 6.6. Механизм получения экземпляров
    • 6.6.1. Получение экземпляров для пустых типов данных
    • 6.6.2. Вывод контекста для предложений получения экземпляров
    • 6.6.3. Отдельные объявления получения экземпляров
    • 6.6.4. Получение экземпляров дополнительных классов (Data и т. д.)
      • 6.6.4.1. Получение экземпляров Functor
      • 6.6.4.2. Получение экземпляров Foldable
      • 6.6.4.3. Получение экземпляров Traversable
      • 6.6.4.4. Получение экземпляров Data
      • 6.6.4.5. Получение экземпляров Typeable
      • 6.6.4.6. Получение экземпляров Lift
    • 6.6.5. Обобщённые производные экземпляры для newtype
      • 6.6.5.1. Обобщение предложения получения экземпляров
      • 6.6.5.2. Более точная спецификация
      • 6.6.5.3. Ассоциированные семейства типов
    • 6.6.6. Получение экземпляров любых других классов
    • 6.6.7. Стратегии получения экземпляров
      • 6.6.7.1. Стратегия получения экземпляров по умолчанию
    • 6.6.8. Получение экземпляров через
  • 6.7. Шаблоны
    • 6.7.1. Ограничители шаблонов
    • 6.7.2. Шаблоны-представления
    • 6.7.3. Шаблоны n+k
    • 6.7.4. Синонимы шаблонов
      • 6.7.4.1. Синонимы шаблонов записей
      • 6.7.4.2. Синтаксис и область видимости синонимов шаблонов
      • 6.7.4.3. Импорт и экспорт синонимов шаблонов
      • 6.7.4.4. Типизация синонимов шаблонов
      • 6.7.4.5. Сопоставление синонимов шаблонов
      • 6.7.4.6. Прагмы для синонимов шаблонов
    • 6.7.5. Шаблоны ИЛИ
      • 6.7.5.1. Спецификация
  • 6.8. Объявления классов и экземпляров
    • 6.8.1. Многопараметрические классы типов
    • 6.8.2. Неопределимые (или рекурсивные) суперклассы
    • 6.8.3. Ограниченные типы методов классов
    • 6.8.4. Сигнатуры методов по умолчанию
    • 6.8.5. Подробные требования к сигнатурам типов по умолчанию
    • 6.8.6. Нульарные классы типов
    • 6.8.7. Функциональные зависимости
      • 6.8.7.1. Правила функциональных зависимостей
      • 6.8.7.2. Общие сведения о функциональных зависимостях
    • 6.8.8. Объявления экземпляров и разрешение
      • 6.8.8.1. Ослабленные правила для заголовка экземпляра
      • 6.8.8.2. Формальный синтаксис типов в объявлениях экземпляров
      • 6.8.8.3. Правила завершения экземпляров
      • 6.8.8.4. Неопределимые экземпляры и циклические суперклассы
      • 6.8.8.5. Перекрывающиеся экземпляры
      • 6.8.8.6. Сигнатуры экземпляров: сигнатуры типов в объявлениях экземпляров
  • 6.9. Литералы
    • 6.9.1. Отрицательные литералы
    • 6.9.2. Двоичные целочисленные литералы
    • 6.9.3. Шестнадцатеричные литералы с плавающей точкой
    • 6.9.4. Целочисленные литералы с видом дробных чисел
    • 6.9.5. Синтаксис примитивных литералов с заданным размером
    • 6.9.6. Подчёркивания в числах
    • 6.9.7. Перегруженные строковые литералы
    • 6.9.8. Перегруженные метки
    • 6.9.9. Многострочные строковые литералы
      • 6.9.9.1. Примеры
  • 6.10. Ограничения
    • 6.10.1. Ослабление ограничений на контексты классов
    • 6.10.2. Ограничения равенства и ограничение Coercible
      • 6.10.2.1. Ограничения равенства
      • 6.10.2.2. Гетерогенное равенство
      • 6.10.2.3. Неподнятое гетерогенное равенство
      • 6.10.2.4. Ограничение Coercible
    • 6.10.3. Вид Constraint
    • 6.10.4. Квантифицированные ограничения
      • 6.10.4.1. Мотивация
      • 6.10.4.2. Изменения синтаксиса
      • 6.10.4.3. Изменения типизации
      • 6.10.4.4. Суперклассы
      • 6.10.4.5. Перекрытие
      • 6.10.4.6. Поиск экземпляров
      • 6.10.4.7. Завершение
      • 6.10.4.8. Согласованность
  • 6.11. Сигнатуры типов
    • 6.11.1. Явная универсальная квантификация (forall)
      • 6.11.1.1. Правило «forall или ничего»
    • 6.11.2. Неоднозначные типы и проверка неоднозначности
    • 6.11.3. Объявления именованных default
      • 6.11.3.1. Мотивация
      • 6.11.3.2. Указание класса
      • 6.11.3.3. Экспорт значений по умолчанию
      • 6.11.3.4. Определение поглощения
      • 6.11.3.5. Правила устранения неоднозначности нескольких объявлений
      • 6.11.3.6. Правила устранения неоднозначности в месте использования
    • 6.11.4. Явная квантификация с указанием вида
    • 6.11.5. Переменные типов с лексической областью видимости
      • 6.11.5.1. Обзор
      • 6.11.5.2. Сигнатуры типов объявлений
      • 6.11.5.3. Сигнатуры типов выражений
      • 6.11.5.4. Сигнатуры типов шаблонов
      • 6.11.5.5. Объявления классов и экземпляров
    • 6.11.6. Неявные параметры
      • 6.11.6.1. Ограничения типов неявных параметров
      • 6.11.6.2. Привязки неявных параметров
      • 6.11.6.3. Неявные параметры и полиморфная рекурсия
      • 6.11.6.4. Гарантии области видимости неявных параметров
      • 6.11.6.5. Неявные параметры и мономорфизм
    • 6.11.7. Частичные сигнатуры типов
      • 6.11.7.1. Синтаксис
      • 6.11.7.2. Где они могут встречаться?
  • 6.12. Привязки и обобщение
    • 6.12.1. Отключение ограничения мономорфизма
    • 6.12.2. Обобщение let-выражений
  • 6.13. Template Haskell
    • 6.13.1. Синтаксис
    • 6.13.2. Уровни и стадии
      • 6.13.2.1. Понимание уровней
      • 6.13.2.2. Сохранение между стадиями
      • 6.13.2.3. Стадии и компиляция
    • 6.13.3. Группы объявлений
      • 6.13.3.1. Различные прочие возможности
    • 6.13.4. Явный импорт уровней
      • 6.13.4.1. Синтаксис и использование
      • 6.13.4.2. Основные примеры
      • 6.13.4.3. Правила уровней и ошибки
      • 6.13.4.4. Экземпляры классов и уровни
      • 6.13.4.5. Импорт Prelude
      • 6.13.4.6. Примечания и ограничения
    • 6.13.5. Использование Template Haskell
    • 6.13.6. Просмотр кода, сгенерированного Template Haskell
    • 6.13.7. Подробный пример Template Haskell
    • 6.13.8. Кавычки Template Haskell и переназначаемый синтаксис
    • 6.13.9. Использование Template Haskell с профилированием
    • 6.13.10. Квазицитирование Template Haskell
  • 6.14. Шаблоны с восклицательным знаком и строгий Haskell
    • 6.14.1. Шаблоны с восклицательным знаком
      • 6.14.1.1. Строгие привязки
    • 6.14.2. Типы данных со строгостью по умолчанию
    • 6.14.3. Привязки шаблонов со строгостью по умолчанию
    • 6.14.4. Модульность
    • 6.14.5. Динамическая семантика шаблонов с восклицательным знаком
  • 6.15. Параллелизм и конкурентность
    • 6.15.1. Конкурентный и параллельный Haskell
      • 6.15.1.1. Конкурентный Haskell
      • 6.15.1.2. Параллельный Haskell
      • 6.15.1.3. Аннотирование чистого кода для параллельного выполнения
    • 6.15.2. Программная транзакционная память
    • 6.15.3. Статические указатели
      • 6.15.3.1. Использование статических указателей
      • 6.15.3.2. Статическая семантика статических указателей
  • 6.16. Неподнятые типы и примитивные операции
    • 6.16.1. Неподнятые типы
    • 6.16.2. Виды неподнятых типов
    • 6.16.3. Неподнятые кортежи
    • 6.16.4. Неподнятые суммы
    • 6.16.5. Неподнятые newtype
    • 6.16.6. Неподнятые типы данных
    • 6.16.7. Примитивные строковые литералы
    • 6.16.8. Десахаризация строковых литералов
  • 6.17. Интерфейс внешних функций (FFI)
    • 6.17.1. Отличия GHC от главы о FFI
      • 6.17.1.1. Гарантированная безопасность вызовов
      • 6.17.1.2. Взаимодействие вызовов safe и привязанных потоков
      • 6.17.1.3. Вариативные аргументы не поддерживаются соглашением о вызовах ccall
    • 6.17.2. Расширения GHC для главы о FFI
      • 6.17.2.1. Неподнятые типы FFI
      • 6.17.2.2. Обёртывание монады IO в newtype
      • 6.17.2.3. Явные «forall» во внешних типах
      • 6.17.2.4. Примитивный импорт
      • 6.17.2.5. Прерываемые внешние вызовы
      • 6.17.2.6. Соглашение о вызовах CAPI
      • 6.17.2.7. hs_thread_done()
      • 6.17.2.8. Эффективное освобождение множества стабильных указателей
    • 6.17.3. Использование FFI с GHC
      • 6.17.3.1. Использование foreign export и foreign import ccall "wrapper" с GHC
      • 6.17.3.2. Использование заголовочных файлов
      • 6.17.3.3. Выделение памяти
      • 6.17.3.4. Многопоточность и FFI
      • 6.17.3.5. Числа с плавающей точкой и FFI
      • 6.17.3.6. Закреплённые массивы байтов
  • 6.18. Безопасный Haskell
    • 6.18.1. Применение безопасного Haskell
      • 6.18.1.1. Строгая безопасность типов (хороший стиль)
      • 6.18.1.2. Создание защищённых систем (ограниченные монады IO)
    • 6.18.2. Безопасный язык
      • 6.18.2.1. Безопасные перекрывающиеся экземпляры
    • 6.18.3. Безопасный импорт
    • 6.18.4. Режимы доверия и безопасного Haskell
      • 6.18.4.1. Проверка доверия (-fpackage-trust отключён)
      • 6.18.4.2. Проверка доверия (-fpackage-trust включён)
      • 6.18.4.3. Пример
      • 6.18.4.4. Требования к Trusted
      • 6.18.4.5. Доверие к пакетам
    • 6.18.5. Вывод безопасного Haskell
    • 6.18.6. Сводка флагов безопасного Haskell
    • 6.18.7. Безопасная компиляция

• • 6.19. Разное
    • 6.19.1. Правила переписывания
      • 6.19.1.1. Синтаксис
      • 6.19.1.2. Семантика
      • 6.19.1.3. Взаимодействие правил с прагмами INLINE/NOINLINE
      • 6.19.1.4. Взаимодействие правил с прагмами CONLIKE
      • 6.19.1.5. Взаимодействие правил с методами классов
      • 6.19.1.6. Слияние списков
      • 6.19.1.7. Специализация
      • 6.19.1.8. Управление процессом переписывания правил
    • 6.19.2. Специальные встроенные функции
    • 6.19.3. Обобщённое программирование
      • 6.19.3.1. Вывод представлений
      • 6.19.3.2. Написание обобщённых функций
      • 6.19.3.3. Неподнятые типы представлений
      • 6.19.3.4. Обобщённые реализации по умолчанию
      • 6.19.3.5. Дополнительные сведения
    • 6.19.4. Утверждения
    • 6.19.5. Макрос CPP __GLASGOW_HASKELL_ASSERTS_IGNORED__
    • 6.19.6. HasCallStack
      • 6.19.6.1. Сравнение с другими источниками трассировок стека
    • 6.19.7. Пробельные символы
  • 6.20. Прагмы
    • 6.20.1. Прагма LANGUAGE
    • 6.20.2. Прагма OPTIONS_GHC
    • 6.20.3. Прагма INCLUDE
    • 6.20.4. Прагмы WARNING и DEPRECATED
    • 6.20.5. Прагма MINIMAL
    • 6.20.6. Прагмы INLINE и NOINLINE
      • 6.20.6.1. Прагма INLINE
      • 6.20.6.2. Прагма INLINABLE
      • 6.20.6.3. Прагма NOINLINE
      • 6.20.6.4. Модификатор CONLIKE
      • 6.20.6.5. Управление фазами
    • 6.20.7. Прагма OPAQUE
    • 6.20.8. Прагма LINE
    • 6.20.9. Прагма COLUMN
    • 6.20.10. Прагма RULES
    • 6.20.11. Прагма SPECIALIZE
      • 6.20.11.1. SPECIALIZE INLINE
      • 6.20.11.2. SPECIALIZE для импортированных функций
    • 6.20.12. Прагма экземпляра SPECIALIZE
    • 6.20.13. Прагма UNPACK
    • 6.20.14. Прагма NOUNPACK
    • 6.20.15. Прагма SOURCE
    • 6.20.16. Прагмы COMPLETE
    • 6.20.17. Прагмы OVERLAPPING, OVERLAPPABLE, OVERLAPS и INCOHERENT
• 7. Расширение GHC и использование его в качестве библиотеки
  • 7.1. Аннотации исходного кода
    • 7.1.1. Аннотирование значений
    • 7.1.2. Аннотирование типов
    • 7.1.3. Аннотирование модулей
  • 7.2. Использование GHC в качестве библиотеки
  • 7.3. Плагины компилятора
    • 7.3.1. Использование плагинов компилятора
    • 7.3.2. Написание плагинов компилятора
    • 7.3.3. Подробнее о плагинах Core
      • 7.3.3.1. Работа с привязками
      • 7.3.3.2. Поздние плагины
      • 7.3.3.3. Использование аннотаций
    • 7.3.4. Плагины проверки типов
      • 7.3.4.1. Решение ограничений с помощью плагинов
      • 7.3.4.2. Переписывание семейств типов с помощью плагинов
    • 7.3.5. Плагины исходного кода
      • 7.3.5.1. Синтаксически разобранное представление
      • 7.3.5.2. Представление с проверенными типами
      • 7.3.5.3. Вычисленный код
      • 7.3.5.4. Файлы интерфейса
      • 7.3.5.5. Пример плагина исходного кода
    • 7.3.6. Плагины для подбора заполнителей
      • 7.3.6.1. Плагины для подбора заполнителей с состоянием
      • 7.3.6.2. Пример плагина для подбора заполнителей
    • 7.3.7. Плагины выбора значений по умолчанию
    • 7.3.8. Управление повторной компиляцией
    • 7.3.9. Плагины интерфейсной части
    • 7.3.10. Плагины DynFlags
  • 7.4. Обращение к серверным частям
    • 7.4.1. Клиентский код, который только указывает имена серверных частей
    • 7.4.2. Клиентский код, различающий серверные части
    • 7.4.3. Общая стратегия миграции клиентского кода
• 8. Профилирование
  • 8.1. Центры затрат и стеки центров затрат
    • 8.1.1. Ручная вставка центров затрат
    • 8.1.2. Правила распределения затрат
  • 8.2. Профилирование и внешние вызовы
  • 8.3. Параметры компилятора для профилирования
    • 8.3.1. Автоматическое размещение центров затрат
  • 8.4. Профилирование времени и выделения памяти
    • 8.4.1. Формат профиля JSON
    • 8.4.2. Формат профиля Eventlog
  • 8.5. Профилирование использования памяти
    • 8.5.1. Параметры RTS для профилирования кучи
    • 8.5.2. Профилирование удерживающих ссылок
      • 8.5.2.1. Советы по использованию профилирования удерживающих ссылок
    • 8.5.3. Точный анализ удерживающих ссылок
    • 8.5.4. Биографическое профилирование
    • 8.5.5. Фактическое пребывание в памяти
  • 8.6. hp2ps — преобразование профилей кучи в PostScript
  • 8.7. Профилирование параллельных и конкурентных программ
  • 8.8. Наблюдение за покрытием кода
    • 8.8.1. Небольшой пример: взаимные величины
    • 8.8.2. Параметры инструментирования кода для сбора данных о покрытии
    • 8.8.3. Набор инструментов hpc
      • 8.8.3.1. hpc report
      • 8.8.3.2. hpc markup
      • 8.8.3.3. hpc sum
      • 8.8.3.4. hpc combine
      • 8.8.3.5. hpc map
      • 8.8.3.6. hpc overlay и hpc draft
    • 8.8.4. Оговорки и ограничения сбора данных о покрытии программ на Haskell
  • 8.9. Использование профилирования «ticky-ticky» (для разработчиков)
    • 8.9.1. Дополнительные флаги Ticky
    • 8.9.2. Интерпретация вывода профилей Ticky-Ticky
    • 8.9.3. Сведения о счётчиках для отдельных имён
    • 8.9.4. Примеры
    • 8.9.5. Примечания о профилировании ticky
• 9. Отладка скомпилированных программ
  • 9.1. Руководство
  • 9.2. Запрос трассировки стека из кода на Haskell
  • 9.3. Запрос трассировки стека с помощью SIGQUIT
  • 9.4. Примечания для разработчиков: аннотации DWARF
    • 9.4.1. Сущности отладочной информации
      • 9.4.1.1. DW_TAG_ghc_src_note
  • 9.5. Дополнительная литература
  • 9.6. Прямое отображение
  • 9.7. Запрос карты таблицы Info
• 10. Что делать, если что-то пошло не так
  • 10.1. Если компилятор «работает неправильно»
  • 10.2. Если программа «работает неправильно»
• 11. Советы
  • 11.1. Быстрее: ускорение создания программы
  • 11.2. Быстрее: создание более быстродействующей программы
  • 11.3. Меньше: создание программы меньшего размера
  • 11.4. Экономнее: создание программы, потребляющей меньше места в куче
  • 11.5. Управление встраиванием с помощью флагов оптимизации.
    • 11.5.1. Создание развёрток
    • 11.5.2. Решения о встраивании
    • 11.5.3. Встраивание обобщённых функций
  • 11.6. Управление специализацией
    • 11.6.1. Часто используемые комбинации флагов и прагм
    • 11.6.2. Доступность развёрток
    • 11.6.3. Когда GHC генерирует специализации
  • 11.7. Как использование памяти ОС соотносится с живыми данными
• 12. Другие вспомогательные программы Haskell
  • 12.1. «Yacc для Haskell»: happy
  • 12.2. Создание интерфейсов Haskell для кода на C: hsc2hs
    • 12.2.1. Синтаксис командной строки
    • 12.2.2. Синтаксис входных данных
    • 12.2.3. Пользовательские конструкции
    • 12.2.4. Кросс-компиляция
• 13. Запуск GHC в системах Win32
  • 13.1. Запуск GHC в Windows
  • 13.2. Запуск GHCi в Windows
  • 13.3. Взаимодействие с терминалом
  • 13.4. Различия в поведении библиотек
  • 13.5. Пути к файлам в Windows
  • 13.6. Использование GHC (и других исполняемых файлов, скомпилированных GHC) с Cygwin
    • 13.6.1. Предыстория
    • 13.6.2. Проблема
    • 13.6.3. Что нужно сделать
  • 13.7. Создание и использование DLL Win32
    • 13.7.1. Создание DLL
    • 13.7.2. Создание DLL для вызова из других языков
      • 13.7.2.1. Использование из VBA
      • 13.7.2.2. Использование из C++
• 14. FFI и бэкенд JavaScript
  • 14.1. Типы FFI для JavaScript
    • 14.1.1. Прерываемое соглашение о вызовах
    • 14.1.2. JSVal
    • 14.1.3. Обратные вызовы JavaScript
    • 14.1.4. Обратные вызовы как внешние экспорты
  • 14.2. Создание заменяющих реализаций библиотек с функциями C FFI
    • 14.2.1. Прямая реализация импортов C FFI на JavaScript в виде jsbits
    • 14.2.2. Написание функций JavaScript, учитывающих среду NodeJS и браузер
    • 14.2.3. Замена импортов C FFI средствами чистого Haskell и JavaScript
  • 14.3. Компоновка с исходными файлами C
    • 14.3.1. Прагмы EMCC
    • 14.3.2. Обёртки
    • 14.3.3. Обратные вызовы
• 15. Использование бэкенда GHC WebAssembly
  • 15.1. Что означает «бэкенд» WebAssembly
  • 15.2. Настройка бэкенда GHC wasm
  • 15.3. Компиляция и компоновка кода с помощью бэкенда GHC wasm
  • 15.4. Запуск результатов работы бэкенда GHC wasm
  • 15.5. Использование GHCi с бэкендом wasm
  • 15.6. JavaScript FFI в бэкенде wasm
    • 15.6.1. Маршализуемые типы и JSVal
    • 15.6.2. Внешние импорты
    • 15.6.3. Внешние экспорты
    • 15.6.4. Проверка использования JSFFI
    • 15.6.5. Взаимодействие с асинхронными исключениями
    • 15.6.6. Взаимодействие с C FFI
    • 15.6.7. API JavaScript

• 16. Известные ошибки и недочёты
  • 16.1. Стандарты Haskell и Glasgow Haskell: несоответствие языковым стандартам
    • 16.1.1. Отличия от Haskell 98 и Haskell 2010
      • 16.1.1.1. Лексический синтаксис
      • 16.1.1.2. Контекстно-свободный синтаксис
      • 16.1.1.3. Выражения и образцы
      • 16.1.1.4. Образцы, допускающие неудачу сопоставления
      • 16.1.1.5. Проверка типов рекурсивных групп привязок
      • 16.1.1.6. Заголовки модулей по умолчанию с -main-is
      • 16.1.1.7. Система модулей и файлы интерфейсов
      • 16.1.1.8. Числа, базовые типы и встроенные классы
      • 16.1.1.9. Поддержка In Prelude
      • 16.1.1.10. Интерфейс внешних функций
    • 16.1.2. Интерпретация GHC неопределённого поведения в Haskell 98 и Haskell 2010
  • 16.2. Известные ошибки и недочёты
    • 16.2.1. Ошибки в GHC
    • 16.2.2. Ошибки в GHCi (интерактивном GHC)
• 17. Форматы журнала событий
  • 17.1. Формат журнала событий
  • 17.2. Диагностика системы выполнения
    • 17.2.1. Наборы возможностей
    • 17.2.2. Сведения о среде
    • 17.2.3. Потоки и события планирования
    • 17.2.4. События сборщика мусора
    • 17.2.5. События и статистика кучи
    • 17.2.6. События Spark
    • 17.2.7. События возможностей
    • 17.2.8. События задач
    • 17.2.9. События трассировки
  • 17.3. Вывод журнала событий профилировщика кучи
    • 17.3.1. Типы событий метаданных
      • 17.3.1.1. Начало потока выборок
      • 17.3.1.2. Определения центров затрат
      • 17.3.1.3. Определения происхождения таблиц Info
      • 17.3.1.4. Типы событий выборок
      • 17.3.1.5. Разбивка по центрам затрат
      • 17.3.1.6. Разбивка строк
  • 17.4. Вывод журнала событий профилировщика времени
    • 17.4.1. Событие начала профилирования
    • 17.4.2. Событие выборки профиля
  • 17.5. Событие биографической выборки профиля
  • 17.6. Вывод событий неперемещающего сборщика мусора
    • 17.6.1. Перепись неперемещающей кучи
    • 17.6.2. Счётчики Ticky
• 18. Глоссарий
• 19. Руководство по сопровождению руководства пользователя GHC
  • 19.1. Основы
    • 19.1.1. Заголовки
    • 19.1.2. Форматирование кода
      • 19.1.2.1. Haskell
      • 19.1.2.2. Другие языки
    • 19.1.3. Ссылки
      • 19.1.3.1. В пределах руководства пользователя
      • 19.1.3.2. На ресурсы GHC
      • 19.1.3.3. На внешние ресурсы
      • 19.1.3.4. На документацию Haddock основной библиотеки
      • 19.1.3.5. Математика
    • 19.1.4. Записи указателя
  • 19.2. Цитаты
  • 19.3. Предупреждения
  • 19.4. Документирование параметров командной строки и команд GHCi
    • 19.4.1. Параметры командной строки
    • 19.4.2. Команды GHCi
  • 19.5. Соглашения о стиле
  • 19.6. Справочные материалы по reST