7.1. Использование GHC

7.1.1. Начало работы: компиляция программ

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

Давайте создадим программу «Hello World», скомпилируем и запустим её. Сначала создайте файл hello.hs содержащий код Haskell:

main = putStrLn "Hello, World!"

Для компиляции программы используйте GHC следующим образом:

$ ghc hello.hs

(где $ представляет собой приглашение: не печатайте его). GHC скомпилирует исходный файл hello.hs, создав объектный файл hello.o и файл интерфейса hello.hi, а затем он свяжет объектный файл с библиотеками, которые поставляются с GHC, для создания исполняемого файла, называемого hello на Unix/Linux/Mac или hello.exe на Windows.

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

Затем мы можем запустить программу так:

$ ./hello
Hello World!

Если ваша программа содержит несколько модулей, то вам нужно только указать GHC имя исходного файла, содержащего Main модуль, и GHC проанализирует import объявления, чтобы найти другие модули, которые составляют программу, и найти их исходные файлы. Это означает, что, за исключением Main модуля, каждый исходный файл должен быть назван по имени модуля, который он содержит (с точками, заменёнными разделителями каталогов). Например, модуль Data.Person будет находиться в файле Data/Person.hs на Unix/Linux/Mac или Data\Person.hs на Windows.

7.1.2. Обзор параметров

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

7.1.2.1. Аргументы командной строки

Вызов GHC принимает следующий вид:

ghc [argument...]

Аргументы командной строки являются либо параметрами, либо именами файлов.

Параметры командной строки начинаются с -. Они не могут быть сгруппированы: -vO отличается от -v -O. Параметры не обязательно должны предшествовать именам файлов: например, ghc *.o -o foo. Все параметры обрабатываются, а затем применяются ко всем файлам; вы не можете, например, вызвать ghc -c -O1 Foo.hs -O2 Bar.hs для применения различных уровней оптимизации к файлам Foo.hs и Bar.hs.

7.1.2.2. Параметры командной строки в исходных файлах

Иногда бывает полезно сделать связь между исходным файлом и необходимыми ему параметрами командной строки достаточно тесной. Например, если файл исходного кода Haskell намеренно использует перекрытие имён, его следует скомпилировать с параметром -Wno-name-shadowing. Вместо того, чтобы поддерживать список параметров для каждого файла в Makefile, это можно сделать непосредственно в исходном файле, используя OPTIONS_GHC псевдоним

{-# OPTIONS_GHC -Wno-name-shadowing #-}
module X where
...

OPTIONS_GHC является псевдонимом заголовка файла (см. псевдоним OPTIONS_GHC).

Только динамические флаги могут использоваться в OPTIONS_GHC псевдониме (см. Динамические и параметры режима).

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

Не рекомендуется перемещать всё содержимое ваших файлов Make в исходные файлы, но в некоторых случаях псевдоним OPTIONS_GHC — это Правильная Вещь. (Если вы используете -keep-hc-file и имеете OPTION флаги в вашем модуле, OPTIONS_GHC будут помещены в сгенерированный .hc файл).

7.1.2.3. Установка параметров в GHCi

Параметры также можно изменить внутри GHCi, используя команду :set.

7.1.3. Динамические и параметры режима

Каждый параметр командной строки GHC классифицируется как динамический или режимный:

Режим: режим может использоваться только в командной строке. Вы можете передать только один флаг режима. Например, --make или -E. Доступные режимы перечислены в Режимы работы.

Динамический: динамический флаг может использоваться в командной строке, в псевдониме OPTIONS_GHC в исходном файле или настраиваться с помощью :set в GHCi.

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

7.1.4. Значимые расширения файлов

Имена файлов со «значимыми» расширениями (например, .lhs или .o) вызывают выполнение «правильной» операции над этими файлами.

.hs

Модуль Haskell.

.lhs

Модуль «литературного Haskell».

.hspp

Файл, созданный препроцессором.

.hi

Файл интерфейса Haskell, вероятно, сгенерированный компилятором.

.hie

Расширенный файл интерфейса Haskell, созданный компилятором Haskell.

.hc

Промежуточный файл C, созданный компилятором Haskell.

.c

Файл C, не созданный компилятором Haskell.

.ll

Файл исходного кода языка LLVM-intermediate, обычно созданный компилятором.

.bc

Файл bitcode языка LLVM-intermediate, обычно созданный компилятором.

.s

Файл исходного кода ассемблера, обычно созданный компилятором.

.o

Объектный файл, созданный ассемблером.

Файлы с другими расширениями (или без расширений) передаются напрямую компоновщику.

7.1.5. Режимы работы

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

$ ghc Main.hs --make -o my-application

Если флаг режима отсутствует, то GHC перейдёт в режим --make (Использование ghc --make), если указаны какие-либо исходные файлы Haskell, или же он свяжет указанные в командной строке объекты, чтобы создать исполняемый файл.

Доступные флаги режима:

--interactive

Интерактивный режим, также доступный как ghci. Интерактивный режим более подробно описан в Использование GHCi.

--make

В этом режиме GHC автоматически построит многомодульную программу Haskell, определив зависимости самостоятельно. Если у вас простая программа Haskell, это, вероятно, будет гораздо проще и быстрее, чем использование make. Режим «make» описан в Использование ghc --make.

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

-e ⟨expr⟩

Режим вычисления выражений. Это очень похоже на интерактивный режим, за исключением того, что существует единственное выражение для вычисления (⟨expr⟩), которое задаётся в командной строке. Более подробную информацию см. в разделе Режим вычисления выражений.

-E

Остановка после предварительной обработки (файл .hspp)

-C

Остановка после генерации C (файл .hc)

-S

Остановка после генерации ассемблерного кода (файл .s)

-c

Остановка после генерации объектного (.o) файла

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

-M

Режим генерации зависимостей. В этом режиме GHC может генерировать информацию о зависимостях, подходящую для использования в Makefile. См. Генерация зависимостей.

--frontend ⟨module⟩

Запуск GHC с указанным плагином передней части. Подробности см. в Плагины передней части.

--mk-dll

Режим создания DLL (только Windows). См. Создание DLL.

--help

-?

Выводит длинное сообщение об использовании в стандартный вывод и затем завершает работу.

--show-iface ⟨file⟩

Считывает интерфейс из ⟨file⟩ и выводит его в текстовом формате в stdout. Например ghc --show-iface M.hi.

--supported-extensions

--supported-languages

Выводит поддерживаемые языковые расширения.

--show-options

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

--info

Выводит информацию о компиляторе.

--version

-V

Выводит строку, включающую номер версии GHC.

--numeric-version

Выводит только числовой номер версии GHC.

--print-libdir

Выводит путь к каталогу библиотек GHC. Это верхняя часть дерева каталогов, содержащих библиотеки GHC, интерфейсы и файлы включения (обычно что-то вроде /usr/local/lib/ghc-5.04 в Unix). Это значение $libdir в файле конфигурации пакета (см. Пакеты).

7.1.5.1. Использование ghc --make

В этом режиме GHC построит многомодульную программу Haskell, следуя зависимостям из одного или нескольких корневых модулей (обычно просто Main). Например, если ваш Main модуль находится в файле Main.hs, вы можете скомпилировать и связать программу так:

ghc --make Main.hs

Фактически, GHC автоматически переходит в режим make, если на командной строке есть файлы Haskell-исходников и не указан другой режим, поэтому в этом случае мы можем просто ввести

ghc Main.hs

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

Основные преимущества использования ghc --make по сравнению с традиционными Makefile заключаются в следующем:

• GHC не нужно перезапускать для каждой компиляции, что означает, что он может кешировать информацию между компиляциями. Компиляция многомодульной программы с помощью ghc --make может быть в два раза быстрее, чем запуск ghc по отдельности для каждого исходного файла.
• Вам не нужно писать Makefile.
• GHC каждый раз пересчитывает зависимости, когда он вызывается, поэтому зависимости никогда не расходятся с исходным кодом.
• Используя флаг -j[⟨n⟩], вы можете компилировать модули параллельно. Укажите -j ⟨n⟩ для компиляции ⟨n⟩ задач параллельно. Если ⟨n⟩ опущено, то оно по умолчанию равно количеству процессоров.

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

Если программе необходимо связаться с дополнительными объектами (например, некоторым вспомогательным кодом C), то объектные файлы можно указать в командной строке, и GHC включит их при компоновке исполняемого файла.

Для обратной совместимости со скриптами make, при использовании в сочетании с -c, этап компоновки опускается (также как и --make -no-link).

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

Исходные файлы программы необязательно должны находиться в одном каталоге; параметр -i можно использовать для добавления каталогов в путь поиска (см. Путь поиска).

-j[⟨n⟩]

Выполнять компиляцию параллельно, где возможно. GHC будет использовать до ⟨N⟩ потоков во время компиляции. Если N опущено, по умолчанию используется количество процессоров. Обратите внимание, что компиляция модуля может не начаться, пока не будут построены его зависимости.

7.1.5.2. Режим вычисления выражений

Этот режим очень похож на интерактивный, за исключением того, что существует одно выражение для вычисления, которое указывается в командной строке в качестве аргумента к параметру -e:

ghc -e expr

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

Например, чтобы загрузить и запустить программу Haskell, содержащую модуль Main, мы можем сказать:

ghc -e Main.main Main.hs

или мы можем использовать этот режим для вычисления выражений в контексте Prelude:

$ ghc -e "interact (unlines.map reverse.lines)"
hello
olleh

7.1.5.3. Режим пакетного компилятора

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

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

Этап системы компиляции	Суффикс, указывающий «начать здесь»	Флаг, указывающий «остановиться после»	(суффикс) выходного файла
предварительный процессор литералов	.lhs		.hs
предварительный процессор C (опционально)	.hs (с -cpp)	-E	.hspp
компилятор Haskell	.hs	-C, -S	.hc, .s
компилятор C (опционально)	.hc или .c	-S	.s
ассемблер	.s	-c	.o
компоновщик	⟨другое⟩		a.out

Таким образом, обычный вызов будет:

ghc -c Foo.hs

для компиляции файла Haskell-исходника Foo.hs в объектный файл Foo.o.

7.1.5.3.1. Переопределение поведения по умолчанию для файла

Как описано выше, способ обработки файла GHC зависит от его суффикса. Это поведение можно переопределить с помощью опции -x ⟨suffix⟩:

-x ⟨suffix⟩

Приводит к тому, что все файлы, следующие за этой опцией в командной строке, обрабатываются так, как будто у них есть суффикс ⟨suffix⟩. Например, чтобы скомпилировать модуль Haskell в файле M.my-hs, используйте ghc -c -x hs M.my-hs.

7.1.6. Опции подробности

См. также режимы --help, --version, --numeric-version, и --print-libdir в Режимы работы.

-v

Опция -v делает GHC подробным: он сообщает свой номер версии и показывает (в stderr) точный способ вызова каждой фазы системы компиляции. Кроме того, он передает флаг -v большинству фаз; каждая фаза сообщает свой номер версии (и, возможно, другую информацию).

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

-v⟨n⟩

Для большего контроля над подробностью вывода компилятора, флаг -v принимает необязательный числовой аргумент. Указание -v само по себе эквивалентно -v3, а другие уровни имеют следующие значения:

-v0

Отключить все неважные сообщения (это значение по умолчанию).

-v1

Минимальная подробность: вывести одну строку за компиляцию (это значение по умолчанию, когда --make или --interactive включены).

-v2

Вывести имя каждой фазы компиляции по мере ее выполнения. (эквивалентно -dshow-passes).

-v3

То же, что и -v2, за исключением того, что дополнительно печатается полная командная строка (если применимо) для каждой фазы компиляции.

-v4

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

-fprint-potential-instances

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

-fhide-source-paths

Начиная с минимальной подробности (-v1, см. -v), GHC отображает имя, путь к исходному файлу и путь к целевому файлу каждого скомпилированного модуля. Этот флаг можно использовать для уменьшения вывода GHC, скрывая пути к исходным и целевым файлам.

Следующие флаги управляют способом отображения GHC типов в сообщениях об ошибках и в GHCi:

-fprint-unicode-syntax

При включенном флаге GHC выводит сигнатуры типов, используя символы Unicode из расширения UnicodeSyntax. Например,

ghci> :set -fprint-unicode-syntax
ghci> :t +v (>>)
(>>) ∷ Monad m ⇒ ∀ a b. m a → m b → m b

-fprint-explicit-foralls

Использование -fprint-explicit-foralls заставляет GHC выводить явное forall квантификацию на верхнем уровне типа; обычно это подавляется. Например, в GHCi:

ghci> let f x = x
ghci> :t f
f :: a -> a
ghci> :set -fprint-explicit-foralls
ghci> :t f
f :: forall a. a -> a

Однако, независимо от установки флага, квантификаторы выводятся в следующих случаях:

• Для вложенного foralls, например:

  ghci> :t GHC.ST.runST
  GHC.ST.runST :: (forall s. GHC.ST.ST s a) -> a
  

• Если какой-либо из квантифицированных переменных типов имеет вид, содержащий переменную вида, например:

  ghci> :i Data.Type.Equality.sym
  Data.Type.Equality.sym ::
    forall k (a :: k) (b :: k).
    (a Data.Type.Equality.:~: b) -> b Data.Type.Equality.:~: a
          -- Defined in Data.Type.Equality
  

Этот флаг также включает вывод выведенных переменных типа в фигурных скобках. См. Выведенные и заданные переменные типа.

-fprint-explicit-kinds

Использование -fprint-explicit-kinds заставляет GHC выводить аргументы вида в типах, которые обычно подавляются. Это может быть важно, когда вы используете полиморфизм видов. Например:

ghci> :set -XPolyKinds
ghci> data T a (b :: l) = MkT
ghci> :t MkT
MkT :: forall k l (a :: k) (b :: l). T a b
ghci> :set -fprint-explicit-kinds
ghci> :t MkT
MkT :: forall k l (a :: k) (b :: l). T @{k} @l a b
ghci> :set -XNoPolyKinds
ghci> :t MkT
MkT :: T @{*} @* a b

В выходных данных выше обратите внимание, что T имеет две переменные вида (k и l) и две переменные типа (a и b). Обратите внимание, что k является выведенной переменной, а l является заданной переменной (см. Выведенные и заданные переменные типа), поэтому они отображаются с помощью немного другой синтаксической конструкции в типе T @{k} @l a b. Применение l (с @l) является стандартным синтаксисом для видимого применения типа (см. Видимое применение типа). Однако применение k (с @{k}) использует гипотетический синтаксис для видимого применения типа выведенной переменной типа. Этот синтаксис в настоящее время не доступен программисту, но он всё же отображается, когда включён -fprint-explicit-kinds.

-fprint-explicit-coercions

Использование -fprint-explicit-coercions заставляет GHC выводить приведения типов. При попытке доказать равенство типов разных видов, GHC использует приведения типов на уровне типов. Пользователям редко нужно видеть их, так как они предназначены для внутренней работы.

-fprint-axiom-incomps

Использование -fprint-axiom-incomps сообщает GHC выводить несовместимости между уравнениями закрытых семейств типов, когда они выводятся командой :info или --show-iface ⟨file⟩.

ghci> :i Data.Type.Equality.==
type family (==) (a :: k) (b :: k) :: Bool
  where
      (==) (f a) (g b) = (f == g) && (a == b)
      (==) a a = 'True
      (==) _1 _2 = 'False
ghci> :set -fprint-axiom-incomps
ghci> :i Data.Type.Equality.==
type family (==) (a :: k) (b :: k) :: Bool
  where
      {- #0 -} (==) (f a) (g b) = (f == g) && (a == b)
      {- #1 -} (==) a a = 'True
          -- incompatible with: #0
      {- #2 -} (==) _1 _2 = 'False
          -- incompatible with: #1, #0

Уравнения нумеруются, начиная с 0, а комментарий после каждого уравнения ссылается на все предыдущие уравнения, с которыми оно несовместимо.

-fprint-equality-relations

Использование -fprint-equality-relations заставляет GHC различать отношения равенства при выводе. Например, ~ — это однородное поднятое равенство (виды его аргументов одинаковы), в то время как ~~ — это разнородное поднятое равенство (виды его аргументов могут быть разными), и ~# — это разнородное неподнятое равенство, внутреннее отношение равенства, используемое в решении GHC. В целом, пользователи не должны беспокоиться о тонкостях; ~ — это то, что вам, вероятно, нужно. Без -fprint-equality-relations, GHC выводит все эти значения как ~. См. также Ограничения равенства.

-fprint-expanded-synonyms

При включенном флаге GHC также выводит типы, расширенные синонимами типов, в сообщениях об ошибках типа. Например, с этими синонимами типов:

type Foo = Int
type Bar = Bool
type MyBarST s = ST s Bar

Это сообщение об ошибке:

Couldn't match type 'Int' with 'Bool'
Expected type: ST s Foo
  Actual type: MyBarST s

Преобразуется в это:

Couldn't match type 'Int' with 'Bool'
Expected type: ST s Foo
  Actual type: MyBarST s
Type synonyms expanded:
Expected type: ST s Int
  Actual type: ST s Bool

-fprint-typechecker-elaboration

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

main :: IO ()
main = do
  return $ let a = "hello" in a
  return ()

Это сообщение о предупреждении:

A do-notation statement discarded a result of type ‘[Char]’
Suppress this warning by saying
  ‘_ <- ($) return let a = "hello" in a’
or by using the flag -fno-warn-unused-do-bind

Преобразуется в это:

A do-notation statement discarded a result of type ‘[Char]’
Suppress this warning by saying
  ‘_ <- ($)
          return
          let
            AbsBinds [] []
              {Exports: [a <= a
                           <>]
               Exported types: a :: [Char]
                               [LclId, Str=DmdType]
               Binds: a = "hello"}
          in a’
or by using the flag -fno-warn-unused-do-bind

-fdefer-diagnostics

Заставляет GHC группировать диагностические сообщения по степени серьезности и выводить их после других сообщений при построении многомодульной программы Haskell. Этот флаг может сделать диагностические сообщения более заметными при совместном использовании с --make и -j[⟨n⟩]. В противном случае, найти соответствующие ошибки или пропустить предупреждения, когда они перемешаны с многими другими сообщениями, может быть сложно.

-fdiagnostics-color=⟨always|auto|never⟩

Приводит к отображению сообщений об ошибках GHC с цветами. Для этого терминал должен поддерживать ANSI-коды цвета, в противном случае текст отобразится искажённо. Значение по умолчанию — auto, что означает, что GHC попытается определить, поддерживает ли терминал цвета, и выбрать соответствующий вариант.

Точная цветовая схема контролируется переменной среды GHC_COLORS (или GHC_COLOURS). Она может быть установлена в виде списка значений, разделенных двоеточием, пар key=value. Вот значения по умолчанию:

header=:message=1:warning=1;35:error=1;31:fatal=1;31:margin=1;34

Каждое значение должно быть подстрокой SGR (Select Graphic Rendition). Форматирование каждого элемента может наследоваться от родительских элементов. Например, если header оставлено пустым, оно будет унаследовать форматирование от message. В противном случае, если header установлено в 1 (жирный шрифт), оно будет полужирным, но при этом унаследует цвет от message.

В настоящее время, в основном сообщении, действует следующее дерево наследования:

• message

  • header

    • warning
    • error
    • fatal

В диагностике с символом «^» в настоящее время нет никакого наследования между margin, warning, error, и fatal.

Переменная среды также может быть установлена в магические значения never или always, что эквивалентно установке соответствующего флага -fdiagnostics-color, но с более низким приоритетом.

-fdiagnostics-show-caret

Управляет отображением строки исходного кода, где была обнаружена ошибка. Это также влияет на связанный символ «^», указывающий на проблемный участок кода. Флаг включён по умолчанию.

-ferror-spans

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

Например:

test.hs:3:6: parse error on input `where'

преобразуется в:

test296.hs:3:6-10: parse error on input `where'

И также возможны многострочные диапазоны:

test.hs:(5,4)-(6,7):
    Conflicting definitions for `a'
    Bound at: test.hs:5:4
              test.hs:6:7
    In the binding group for: a, b, a

Обратите внимание, что нумерация строк начинается с единицы, а нумерация столбцов — с нуля. Такое решение было принято для соответствия существующей практике (то есть, так делает Emacs).

-fkeep-going

Since

8.10.1

Приводит к продолжению компиляции, если в модуле есть ошибка. Любые обратные зависимости удаляются немедленно, и вся компиляция по-прежнему отмечается как ошибка. Этот параметр не влияет, если используется параллельная компиляция (-j[⟨n⟩]).

-freverse-errors

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

-H ⟨size⟩

Устанавливает минимальный размер кучи в ⟨size⟩. Этот параметр эквивалентен +RTS -Hsize, см. параметры RTS для управления сборщиком мусора.

-Rghc-timing

Выводит краткое сводное описание статистики времени выполнения для запуска GHC. Этот параметр эквивалентен +RTS -tstderr, см. параметры RTS для управления сборщиком мусора.

7.1.7. Параметры, специфичные для платформы

Некоторые параметры имеют смысл только для определённых целевых платформ.

-msse2

(только x86, добавлено в GHC 7.0.1) Использует регистры и набор инструкций SSE2 для выполнения операций с плавающей точкой при использовании генератора кода для нативного кода. Это даёт существенное улучшение производительности для операций с плавающей точкой, но полученный скомпилированный код будет работать только на процессорах, поддерживающих SSE2 (Intel Pentium 4 и более поздние, или AMD Athlon 64 и более поздние). Backend LLVM также будет использовать SSE2, если ваш процессор его поддерживает, но обнаруживает это автоматически, поэтому флаг не требуется.

SSE2 используется безусловно на платформах x86-64.

-msse4.2

(только x86, добавлено в GHC 7.4.1) Использует набор инструкций SSE4.2 для реализации некоторых операций с плавающей точкой и операций по битам при использовании генератора кода для нативного кода. Полученный скомпилированный код будет работать только на процессорах, поддерживающих SSE4.2 (Intel Core i7 и более поздние). Backend LLVM также будет использовать SSE4.2, если ваш процессор его поддерживает, но обнаруживает это автоматически, поэтому флаг не требуется.

-mbmi2

(только x86, добавлено в GHC 7.4.1) Использует набор инструкций BMI2 для реализации некоторых операций по битам при использовании генератора кода для нативного кода. Полученный скомпилированный код будет работать только на процессорах, поддерживающих BMI2 (Intel Haswell и более новые, AMD Excavator, Zen и более новые).

7.1.8. Разные флаги

Некоторые флаги имеют смысл только для определённого случая использования.

-ghcversion-file ⟨path to ghcversion.h⟩

При использовании GHC для компиляции файлов C, GHC добавляет пути к включению пакетов и включает ghcversion.h напрямую. Компилятор будет искать путь к файлу ghcversion.h пакета rts в базе данных пакетов. В некоторых случаях база данных пакетов компилятора не содержит пакет rts, или нужно указать конкретный ghcversions.h для включения. Этот параметр можно использовать для указания пути к файлу ghcversions.h для включения. Это в первую очередь предназначено для использования системой сборки GHC.

7.1.8.1. Другие переменные среды

GHC также может быть настроен с помощью переменных среды. В настоящее время единственная поддерживаемая переменная — GHC_NO_UNICODE, которая, при установке, отключает вывод Unicode независимо от настроек локали. GHC_NO_UNICODE может быть установлена на любое значение (даже пустая строка) для активации этого поведения.