3. Использование GHCi

3.1. Введение в GHCi

Начнём с примера сеанса GHCi. Запустить GHCi можно командой ghci:

$ ghci
GHCi, version 8.y.z: https://www.haskell.org/ghc/  :? for help
ghci>

Загрузка стандартного модуля Prelude и стандартных библиотек может занять некоторое время, после чего появится приглашение. Как сказано в приветственном сообщении, можно ввести :?, чтобы увидеть список доступных команд и краткое описание каждой из них. Мы рассмотрим большинство этих команд по ходу изложения; полная документация по всем командам приведена в разделе Команды GHCi.

В приглашении можно вводить выражения Haskell:

ghci> 1+2
3
ghci> let x = 42 in x / 9
4.666666666666667
ghci>

GHCi интерпретирует всю строку как выражение, которое нужно вычислить. Выражение не может занимать несколько строк: как только вы нажмёте Enter, GHCi попытается его вычислить.

В Haskell за выражением let следует in. Однако в GHCi, поскольку выражение также может интерпретироваться в монаде IO, о привязке let без соответствующего оператора in можно сообщить пустой строкой, как в примере выше.

Начиная с GHC 8.0.1, можно привязывать значения и функции к именам без оператора let:

ghci> x = 42
ghci> x
42
ghci>

3.2. Загрузка исходных файлов

Предположим, у нас есть следующий исходный код на Haskell, который мы поместим в файл Main.hs:

main = print (fac 20)

fac 0 = 1
fac n = n * fac (n-1)

Файл Main.hs можно сохранить в любом месте, но если вы сохраните его не в текущем каталоге [3], нам нужно будет перейти в нужный каталог в GHCi:

ghci> :cd dir

где ⟨dir⟩ — каталог (или папка), в котором вы сохранили Main.hs.

Чтобы загрузить исходный файл Haskell в GHCi, используйте команду :load:

ghci> :load Main
Compiling Main             ( Main.hs, interpreted )
Ok, modules loaded: Main.
*ghci>

GHCi загрузил модуль Main, а приглашение изменилось на *ghci>, показывая, что текущий контекст для выражений, вводимых в приглашении, — это только что загруженный модуль Main (позже мы объясним, что означает *, в разделе Что на самом деле доступно в приглашении?). Теперь мы можем вводить выражения, использующие функции из Main.hs:

*ghci> fac 17
355687428096000

Загрузить программу из нескольких модулей так же просто: достаточно передать команде :load имя «верхнего» модуля (подсказка: команду :load можно сократить до :l). Верхним модулем обычно будет Main, но это необязательно. GHCi определит, какие модули прямо или косвенно требуются верхнему модулю, и загрузит их все в порядке зависимостей.

-fshow-loaded-modules

По умолчанию:

выкл.

Начиная с версии:

8.2.2

Обычно после команды :load GHCi показывает только количество загруженных модулей. При использовании этого флага GHC также выводит имена загруженных модулей. До GHC 8.2.1 такое поведение использовалось по умолчанию; оно может быть полезно некоторым пользователям инструментов.

ghci -idir1:...:dirn

3.3. Загрузка скомпилированного кода

При загрузке исходного модуля Haskell в GHCi он обычно преобразуется в байт-код и выполняется интерпретатором. Однако в GHCi интерпретируемый код может работать одновременно со скомпилированным; более того, обычно при запуске GHCi загружает скомпилированную копию пакета base, содержащего Prelude.

Зачем запускать скомпилированный код? Скомпилированный код примерно в 10 раз быстрее интерпретируемого, но его создание занимает примерно в 2 раза больше времени (возможно, ещё дольше при включённой оптимизации). Поэтому имеет смысл компилировать те части программы, которые меняются нечасто, а для активно разрабатываемого кода использовать интерпретатор.

При загрузке исходных модулей с помощью :load GHCi обычно ищет соответствующие скомпилированные объектные файлы и, если это возможно, предпочитает их интерпретации исходного кода. Например, предположим, что у нас есть программа из четырёх модулей: A, B, C и D. Модули B и C импортируют только D, а A импортирует и B, и C:

  A
 / \
B   C
 \ /
  D

Сначала скомпилируем D, а затем загрузим всю программу:

ghci> :! ghc -c -this-unit-id interactive-session -dynamic D.hs
ghci> :load A B C D
Compiling B                ( B.hs, interpreted )
Compiling C                ( C.hs, interpreted )
Compiling A                ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D (D.o).
*ghci>

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

Обратите внимание на флаг -dynamic, переданный GHC: GHCi использует динамически компонуемый объектный код (если платформа это поддерживает), поэтому для использования скомпилированного кода в GHCi его необходимо скомпилировать для динамической компоновки.

Также обратите внимание на параметр -this-unit-id ⟨unit-id⟩ interactive-session, переданный GHC: GHCi может использовать объектный код модуля, загруженного с помощью :load, только если объектный код был скомпилирован для interactive-session.

В любой момент можно использовать команду :show modules, чтобы получить список модулей, загруженных в GHCi:

*ghci> :show modules
D                ( D.hs, D.o )
C                ( C.hs, interpreted )
B                ( B.hs, interpreted )
A                ( A.hs, interpreted )
*ghci>

Если теперь изменить исходный код D (или сделать вид, что вы его изменили: для этого удобно использовать команду Unix touch для исходного файла), компилятор больше не сможет использовать объектный файл, поскольку он может устареть:

*ghci> :! touch D.hs
*ghci> :reload
Compiling D                ( D.hs, interpreted )
Ok, modules loaded: A, B, C, D.
*ghci>

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

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

*ghci> :! ghc -c -this-unit-id interactive-session -dynamic C.hs
*ghci> :load A B C D
Compiling D                ( D.hs, interpreted )
Compiling B                ( B.hs, interpreted )
Compiling C                ( C.hs, interpreted )
Compiling A                ( A.hs, interpreted )
Ok, modules loaded: A, B, C, D.

Мы не получили скомпилированную версию C! Что произошло? В GHCi скомпилированный модуль может зависеть только от других скомпилированных модулей, а в данном случае C зависит от D, для которого нет объектного файла, поэтому GHCi также отклонил объектный файл C. Хорошо, скомпилируем также D:

*ghci> :! ghc -c -this-unit-id interactive-session -dynamic D.hs
*ghci> :reload
Ok, modules loaded: A, B, C, D.

Ничего не произошло! Вот ещё один важный момент: вновь скомпилированные модули подхватываются не командой :reload, а только командой :load:

*ghci> :load A B C D
Compiling B                ( B.hs, interpreted )
Compiling A                ( A.hs, interpreted )
Ok, modules loaded: A, B, C (C.o), D (D.o).

Автоматическая загрузка объектных файлов иногда может вызывать путаницу: определения верхнего уровня, не экспортируемые модулем, доступны для использования в выражениях, вводимых в приглашении, только когда модуль интерпретируется (см. Что на самом деле доступно в приглашении?). Поэтому иногда может понадобиться принудительно загрузить модуль в GHCi с помощью интерпретатора. Для этого при использовании :load добавьте перед именем модуля или файла *, например:

ghci> :load *A
Compiling A                ( A.hs, interpreted )
*ghci>

Если используется *, GHCi игнорирует предварительно скомпилированный объектный код и интерпретирует модуль. Если вы уже загрузили несколько модулей в виде объектного кода и решили интерпретировать один из них, вместо повторной загрузки всего набора можно использовать :add *M, чтобы указать, что нужно интерпретировать M (обратите внимание, что это может привести к интерпретации и других модулей, поскольку скомпилированные модули не могут зависеть от интерпретируемых).

Чтобы всегда компилировать всё в объектный код и никогда не использовать интерпретатор, задайте параметр -fobject-code (см. Компиляция в объектный код в GHCi).

3.4. Интерактивное вычисление в командной строке

Когда вы вводите выражение в командной строке, GHCi немедленно вычисляет его и выводит результат:

ghci> reverse "hello"
"olleh"
ghci> 5+5
10

ghci> "hello"
"hello"
ghci> putStrLn "hello"
hello

ghci> return True
True

ghci> putStrLn "hello"
hello
ghci> do { putStrLn "hello"; return "yes" }
hello
"yes"

ghci> x <- return 42
ghci> print x
42
ghci>

ghci> let x = 42
ghci> x
42
ghci>

ghci> let x = error "help!"
ghci> print x
*** Exception: help!
ghci>

ghci> add a b = a + b
ghci> add 1 2
3
ghci>

ghci> f op n [] = n ; f op n (h:t) = h `op` f op n t
ghci> f (+) 0 [1..3]
6
ghci>

ghci> :{
ghci| g op n [] = n
ghci| g op n (h:t) = h `op` g op n t
ghci| :}
ghci> g (*) 1 [1..3]
6

ghci> :show bindings
x :: Int
ghci>

ghci> :set +t
ghci> let (x:xs) = [1..]
x :: Integer
xs :: [Integer]

ghci> :set +m
ghci> let x = 42
ghci|

ghci> :set +m
ghci> let x = 42
ghci|     y = 3
ghci|
ghci>

ghci> do {
ghci| putStrLn "hello"
ghci| ;putStrLn "world"
ghci| }
hello
world
ghci>

ghci> flip evalStateT 0 $ do
ghci| i <- get
ghci| lift $ do
ghci|   putStrLn "Hello World!"
ghci|   print i
ghci|
"Hello World!"
0
ghci>

ghci> do
ghci| putStrLn "Hello, World!"
ghci| ^C
ghci>

ghci> data T = A | B | C deriving (Eq, Ord, Show, Enum)
ghci> [A ..]
[A,B,C]
ghci> :i T
data T = A | B | C      -- Defined at <interactive>:2:6
instance Enum T -- Defined at <interactive>:2:45
instance Eq T -- Defined at <interactive>:2:30
instance Ord T -- Defined at <interactive>:2:34
instance Show T -- Defined at <interactive>:2:39

ghci> data T = A | B
ghci> let f A = True; f B = False
ghci> data T = A | B | C
ghci> f A

<interactive>:2:3:
    Couldn't match expected type `main::Interactive.T'
                with actual type `T'
    In the first argument of `f', namely `A'
    In the expression: f A
    In an equation for `it': it = f A
ghci>

ghci> type family T a b
ghci> type instance T a b = a
ghci> let uc :: a -> T a b; uc = id

ghci> type instance T a b = b

<interactive>:3:15: error:
    Conflicting family instance declarations:
      T a b = a -- Defined at <interactive>:3:15
      T a b = b -- Defined at <interactive>:5:15

-- Darn! We have to re-declare T.

ghci> type family T a b
-- This is a brand-new T, unrelated to the old one
ghci> type instance T a b = b
ghci> uc 'a' :: Int

<interactive>:8:1: error:
    • Couldn't match type ‘Char’ with ‘Int’
      Expected type: Int
        Actual type: Ghci1.T Char b0
    • In the expression: uc 'a' :: Int
      In an equation for ‘it’: it = uc 'a' :: Int

ghci>

ghci> :load hello.hs
[1 of 1] Compiling Main             ( hello.hs, interpreted )
Ok, modules loaded: Main.
*ghci> :show imports
:module +*Main -- added automatically
*ghci>

ghci> import System.IO
ghci> hPutStrLn stdout "hello\n"
hello

ghci> import System.IO
ghci> import Data.Map as Map
ghci Map> :show imports
import Prelude -- implicit
import System.IO
import Data.Map as Map

:module +|- *mod1 ... *modn

ghci> let foo = True
ghci> let foo = False
ghci> :show bindings
foo :: Bool = False

ghci> data T = A | B deriving Eq
ghci> let a = A
ghci> data T = ANewType
ghci> :t a
a :: Ghci1.T

ghci> a == Ghci1.A
True
ghci> let a = False -- shadowing a
ghci> Ghci2.a == Ghci1.A
True

ghci> 1+2
3
ghci> it * 2
6

let it = e;
print it

ghci> id

<interactive>:1:0:
    No instance for (Show (a -> a))
      arising from use of `print' at <interactive>:1:0-1
    Possible fix: add an instance declaration for (Show (a -> a))
    In the expression: print it
    In a 'do' expression: print it

ghci> Data.Time.getZonedTime
2017-04-10 12:34:56.93213581 UTC
ghci> print it
2017-04-10 12:34:56.93213581 UTC

it <- e

ghci> reverse []

ghci> reverse ([] :: String)
""
ghci> reverse ([] :: [Int])
[]

main :: IO ()
main = print def

instance Num ()

def :: (Num a, Enum a) => a
def = toEnum 0

default (Maybe, Integer, Double)

module SpecPrinter where
import System.IO

sprint a = putStrLn $ show a ++ "!"

ghci -interactive-print=SpecPrinter.sprint SpecPrinter

*SpecPrinter> [1,2,3]
[1,2,3]!
*SpecPrinter> 42
42!

% ghc -e "[1,2,3]" -interactive-print=SpecPrinter.sprint SpecPrinter
[1,2,3]!

3.5. Отладчик GHCi

GHCi содержит простой отладчик в императивном стиле, позволяющий приостанавливать выполняющиеся вычисления, чтобы проверять значения переменных. Отладчик интегрирован в GHCi и включён по умолчанию: для включения средств отладки флаги не требуются. Есть одно важное ограничение: точки останова и пошаговое выполнение доступны только в интерпретируемых модулях; скомпилированный код отладчику недоступен [5].

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

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

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

-fbreak-points

По умолчанию:

включён для GHCi

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

qsort [] = []
qsort (a:as) = qsort left ++ [a] ++ qsort right
  where (left,right) = (filter (<=a) as, filter (>a) as)

main = print (qsort [8, 4, 0, 3, 1, 23, 11, 18])

ghci> :l qsort.hs
[1 of 1] Compiling Main             ( qsort.hs, interpreted )
Ok, modules loaded: Main.
*ghci>

*ghci> :break 2
Breakpoint 0 activated at qsort.hs:2:15-46
*ghci>

*ghci> main
Stopped at qsort.hs:2:15-46
_result :: [a]
a :: a
left :: [a]
right :: [a]
[qsort.hs:2:15-46] *ghci>

[qsort.hs:2:15-46] *ghci> :list
1  qsort [] = []
2  qsort (a:as) = qsort left ++ [a] ++ qsort right
3    where (left,right) = (filter (<=a) as, filter (>a) as)

[qsort.hs:2:15-46] *ghci> left

<interactive>:1:0:
    Ambiguous type variable `a' in the constraint:
      `Show a' arising from a use of `print' at <interactive>:1:0-3
    Cannot resolve unknown runtime types: a
    Use :print or :force to determine these types

[qsort.hs:2:15-46] *ghci> :set -fprint-evld-with-show
[qsort.hs:2:15-46] *ghci> :print left
left = (_t1::[a])

[qsort.hs:2:15-46] *ghci> :force left
left = [4,0,3,1]

[qsort.hs:2:15-46] *ghci> :show bindings
_result :: [Integer]
a :: Integer
left :: [Integer]
right :: [Integer]
_t1 :: [Integer]

[qsort.hs:2:15-46] *ghci> a
8

[qsort.hs:2:15-46] *ghci> :print right
right = (_t1::[Integer])
[qsort.hs:2:15-46] *ghci> seq _t1 ()
()
[qsort.hs:2:15-46] *ghci> :print right
right = 23 : (_t2::[Integer])

[qsort.hs:2:15-46] *ghci> :continue
Stopped at qsort.hs:2:15-46
_result :: [a]
a :: a
left :: [a]
right :: [a]
[qsort.hs:2:15-46] *ghci>

:break identifier

:break [ModQual.]topLevelIdent[.nestedIdent]...[.nestedIdent]

foo s = 'a' : add s
    where add = (++"z")

:break Main.foo.add
:break foo.add

:break line
:break line column
:break module line
:break module line column

*ghci> :show breaks
[0] Main qsort.hs:1:11-12 enabled
[1] Main qsort.hs:2:15-46 enabled

*ghci> :disable 0
*ghci> :show breaks
[0] Main qsort.hs:1:11-12 disabled
[1] Main qsort.hs:2:15-46 enabled

*ghci> :delete 0
*ghci> :show breaks
[1] Main qsort.hs:2:15-46 disabled

*ghci> :step main
Stopped at qsort.hs:5:7-47
_result :: IO ()

[qsort.hs:5:7-47] *ghci> :list
4
5  main = print (qsort [8, 4, 0, 3, 1, 23, 11, 18])
6
[qsort.hs:5:7-47] *ghci>

[qsort.hs:5:7-47] *ghci> :set stop :list
[qsort.hs:5:7-47] *ghci> :step
Stopped at qsort.hs:5:14-46
_result :: [Integer]
4
5  main = print (qsort [8, 4, 0, 3, 1, 23, 11, 18])
6
[qsort.hs:5:14-46] *ghci>

[qsort.hs:2:15-46] *ghci> :st qsort [1,3]
Stopped at qsort.hs:(1,0)-(3,55)
_result :: [a]
... [qsort.hs:(1,0)-(3,55)] *ghci>

... [qsort.hs:(1,0)-(3,55)] *ghci> :show context
--> main
  Stopped at qsort.hs:2:15-46
--> qsort [1,3]
  Stopped at qsort.hs:(1,0)-(3,55)
... [qsort.hs:(1,0)-(3,55)] *ghci>

... [qsort.hs:(1,0)-(3,55)] *ghci> :abandon
[qsort.hs:2:15-46] *ghci> :abandon
*ghci>

*ghci> :list qsort
1  qsort [] = []
2  qsort (a:as) = qsort left ++ [a] ++ qsort right
3    where (left,right) = (filter (<=a) as, filter (>a) as)
4
*ghci> :b 1
Breakpoint 1 activated at qsort.hs:1:11-12
*ghci>

*ghci> :trace qsort [3,2,1]
Stopped at qsort.hs:1:11-12
_result :: [a]
[qsort.hs:1:11-12] *ghci>

[qsort.hs:1:11-12] *ghci> :hist
-1  : qsort.hs:3:24-38
-2  : qsort.hs:3:23-55
-3  : qsort.hs:(1,0)-(3,55)
-4  : qsort.hs:2:15-24
-5  : qsort.hs:2:15-46
-6  : qsort.hs:3:24-38
-7  : qsort.hs:3:23-55
-8  : qsort.hs:(1,0)-(3,55)
-9  : qsort.hs:2:15-24
-10 : qsort.hs:2:15-46
-11 : qsort.hs:3:24-38
-12 : qsort.hs:3:23-55
-13 : qsort.hs:(1,0)-(3,55)
-14 : qsort.hs:2:15-24
-15 : qsort.hs:2:15-46
-16 : qsort.hs:(1,0)-(3,55)
<end of history>

[qsort.hs:1:11-12] *ghci> :back
Logged breakpoint at qsort.hs:3:24-38
_result :: [a]
as :: [a]
a :: a
[-1: qsort.hs:3:24-38] *ghci>

*ghci> :set -fbreak-on-exception
*ghci> :trace qsort ("abc" ++ undefined)
“Stopped at <exception thrown>
_exception :: e
[<exception thrown>] *ghci> :hist
-1  : qsort.hs:3:24-38
-2  : qsort.hs:3:23-55
-3  : qsort.hs:(1,0)-(3,55)
-4  : qsort.hs:2:15-24
-5  : qsort.hs:2:15-46
-6  : qsort.hs:(1,0)-(3,55)
<end of history>
[<exception thrown>] *ghci> :back
Logged breakpoint at qsort.hs:3:24-38
_result :: [a]
as :: [a]
a :: a
[-1: qsort.hs:3:24-38] *ghci> :force as
*** Exception: Prelude.undefined
[-1: qsort.hs:3:24-38] *ghci> :print as
as = 'b' : 'c' : (_t1::[Char])

import Prelude hiding (map)

map :: (a->b) -> [a] -> [b]
map f [] = []
map f (x:xs) = f x : map f xs

*ghci> :break 5
Breakpoint 0 activated at  map.hs:5:15-28
*ghci> map Just [1..5]
Stopped at map.hs:(4,0)-(5,12)
_result :: [b]
x :: a
f :: a -> b
xs :: [a]

*ghci> seq x ()
*ghci> :print x
x = 1

*ghci> :t x
x :: Integer
*ghci> :t f
f :: Integer -> b

*ghci> let b = f 10
*ghci> :t b
b :: b
*ghci> b
<interactive>:1:0:
    Ambiguous type variable `b' in the constraint:
      `Show b' arising from a use of `print' at <interactive>:1:0
*ghci> :p b
b = (_t2::a)
*ghci> seq b ()
()
*ghci> :t b
b :: a
*ghci> :p b
b = Just 10
*ghci> :t b
b :: Maybe Integer
*ghci> :t f
f :: Integer -> Maybe Integer
*ghci> f 20
Just 20
*ghci> map f [1..5]
[Just 1, Just 2, Just 3, Just 4, Just 5]

3.6. Запуск GHCi

GHCi запускается командой ghci или ghc --interactive. В командной строке также можно указать один или несколько модулей или имён файлов; это указывает GHCi загрузить указанные модули или файлы (и все модули, от которых они зависят), как если бы вы ввели :load modules в приглашении GHCi (см. Команды GHCi). Например, чтобы запустить GHCi и загрузить программу, верхний модуль которой находится в файле Main.hs, можно ввести:

$ ghci Main.hs

Большинство параметров командной строки, принимаемых GHC (см. Использование GHC), имеют смысл и в интерактивном режиме. Параметры, которые не имеют смысла, в основном очевидны.

-flocal-ghci-history

По умолчанию GHCi хранит глобальную историю в $XDG_DATA_HOME/ghc/ghci_history или %APPDATA%/<app>/ghci_history, но вместо этого можно использовать текущий каталог, например:

$ ghci -flocal-ghci-history

В текущей папке, из которой запущен GHCi, будет создан .ghci-history.

-fghci-leak-check

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

-fload-initial-targets

По умолчанию:

включено

Начиная с версии:

9.14.1

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

$ ghci -package readline
GHCi, version 8.y.z: https://www.haskell.org/ghc/  :? for help
Loading package base ... linking ... done.
Loading package readline-1.0 ... linking ... done.
ghci>

ghci> :set -package name

$ ghci -lm

3.7. Команды GHCi

Все команды GHCi начинаются с «:» и состоят из одного имени команды, за которым следует ноль или более параметров. Имя команды можно сокращать; неоднозначность разрешается в пользу наиболее часто используемых команд.

:abandon

Прерывает текущую оценку (доступно только при остановке в точке останова).

:add [*]⟨module⟩

Добавляет модуль или модули ⟨module⟩ в текущий набор целей и выполняет перезагрузку. Обычно загружается предварительно скомпилированный код модуля, если он доступен, в противном случае модуль компилируется в байт-код. Префикс * принудительно загружает модуль как байт-код.

⟨module⟩ может быть путём к файлу. Символ «~» в начале ⟨module⟩ заменяется содержимым переменной окружения HOME.

:all-types

Выводит список всех типов, собранных для выражений и (локальных) привязок, загруженных в данный момент (при активном параметре :set +c), с указанием соответствующего диапазона исходного кода, например:

GhciTypes> :all-types
GhciTypes.hs:(38,13)-(38,24): Maybe Id
GhciTypes.hs:(45,10)-(45,29): Outputable SpanInfo
GhciTypes.hs:(45,10)-(45,29): (Rational -> SpanInfo -> SDoc) -> Outputable SpanInfo

:back ⟨n⟩

Перемещается назад на ⟨n⟩ шагов по истории. Если ⟨n⟩ не указано, оно равно единице. Подробнее о средствах отладки GHCi см. в разделе Трассировка и история. См. также: :trace, :history, :forward.

:break [⟨identifier⟩ | [⟨module⟩] ⟨line⟩ [⟨column⟩]]

Устанавливает точку останова на указанной функции или строке и столбце. См. раздел Установка точек останова.

:browse[!] [[*] ⟨module⟩]

Показывает идентификаторы, экспортируемые модулем ⟨module⟩, который должен быть загружен в GHCi или входить в пакет. Если ⟨module⟩ не указан, используется последний загруженный модуль.

Как и все остальные команды GHCi, вывод всегда отображается в текущем контексте GHCi (Что на самом деле доступно в области видимости в приглашении?).

У команды browse есть два варианта:

• Если перед именем модуля поставить символ *, будут показаны все идентификаторы, доступные в области видимости ⟨module⟩ (а не только его экспортируемые идентификаторы).

  Форма с * доступна только для интерпретируемых модулей; для скомпилированных модулей (в том числе модулей из пакетов) доступна только форма :browse без *.

• Конструкторы данных и методы классов обычно отображаются в контексте объявления их типа данных или класса. Однако если к команде добавить символ !, то есть указать :browse!, они будут перечислены по отдельности. Форма с ! также сопровождает список комментариями с возможными импортами для каждой группы элементов. Пример:

  ghci> :browse! Data.Maybe
  -- not currently imported
  Data.Maybe.catMaybes :: [Maybe a] -> [a]
  Data.Maybe.fromJust :: Maybe a -> a
  Data.Maybe.fromMaybe :: a -> Maybe a -> a
  Data.Maybe.isJust :: Maybe a -> Bool
  Data.Maybe.isNothing :: Maybe a -> Bool
  Data.Maybe.listToMaybe :: [a] -> Maybe a
  Data.Maybe.mapMaybe :: (a -> Maybe b) -> [a] -> [b]
  Data.Maybe.maybeToList :: Maybe a -> [a]
  -- imported via Prelude
  Just :: a -> Maybe a
  data Maybe a = Nothing | Just a
  Nothing :: Maybe a
  maybe :: b -> (a -> b) -> Maybe a -> b
  

  Этот вывод показывает, что в контексте текущего сеанса (то есть в области видимости Prelude) первая группа элементов из Data.Maybe недоступна (хотя к ним можно обратиться по полному имени в сеансе GHCi — см. раздел Что на самом деле доступно в области видимости в приглашении?), а вторая группа элементов доступна (через Prelude) и поэтому может использоваться как без квалификатора, так и с квалификатором Prelude..

:cd ⟨dir⟩

Изменяет текущий рабочий каталог на ⟨dir⟩. Символ «~» в начале ⟨dir⟩ заменяется содержимым переменной окружения HOME. Чтобы узнать текущий рабочий каталог, см. также команду :show paths.

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

:cmd ⟨expr⟩

Выполняет ⟨expr⟩ как вычисление типа IO String, а затем выполняет полученную строку как список команд GHCi. Несколько команд разделяются символами новой строки. Команда :cmd полезна в сочетании с командами :def и :set stop.

:complete ⟨type⟩ [⟨n⟩-][⟨m⟩] ⟨string-literal⟩

Эта команда позволяет запрашивать варианты автодополнения в GHCi даже при работе через канал, а не через полноценный терминал, и предназначена для интеграции автодополнения GHCi с текстовыми редакторами и IDE.

При вызове :complete выводит варианты автодополнения с ⟨n⟩^-го по ⟨m⟩^-й для частичного ввода ⟨string-literal⟩ в области автодополнения, заданной параметром ⟨type⟩. В настоящее время поддерживается только область repl, обозначающая вид автодополнения, который GHCi интерактивно предлагает в приглашении ввода.

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

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

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

За строкой заголовка следуют ⟨l⟩ строк, каждая из которых содержит один вариант автодополнения, закодированный как (заключённый в кавычки) строковый литерал. Ниже приведены примеры вызовов для разных случаев:

ghci> :complete repl 0 ""
0 470 ""
ghci> :complete repl 5 "import For"
5 21 "import "
"Foreign"
"Foreign.C"
"Foreign.C.Error"
"Foreign.C.String"
"Foreign.C.Types"
ghci> :complete repl 5-10 "import For"
6 21 "import "
"Foreign.C.Types"
"Foreign.Concurrent"
"Foreign.ForeignPtr"
"Foreign.ForeignPtr.Safe"
"Foreign.ForeignPtr.Unsafe"
"Foreign.Marshal"
ghci> :complete repl 20- "import For"
2 21 "import "
"Foreign.StablePtr"
"Foreign.Storable"
ghci> :complete repl "map"
3 3 ""
"map"
"mapM"
"mapM_"
ghci> :complete repl 5-10 "map"
0 3 ""

:continue [⟨ignoreCount⟩]

Продолжает текущее вычисление, остановленное в точке останова.

Если указано ⟨ignoreCount⟩, программа пропустит текущую точку останова в течение следующих ⟨ignoreCount⟩ итераций. См. команду :ignore.

:def[!] ⟨name⟩ ⟨expr⟩

:def используется для определения новых команд, или макросов, в GHCi. Команда :def ⟨name⟩ ⟨expr⟩ определяет новую команду GHCi :name, реализованную выражением Haskell ⟨expr⟩, тип которого должен быть String -> IO String. Когда в приглашении вводится :name args, GHCi выполняет выражение (name args), получает результат String и передаёт его обратно в GHCi как новую последовательность команд. Отдельные команды в результате должны разделяться символом «\n».

Всё это может показаться немного запутанным, поэтому приведём несколько примеров. Для начала определим новую команду GHCi, которая не принимает аргументов и ничего не возвращает, а лишь выводит текущие дату и время:

ghci> let date _ = Data.Time.getZonedTime >>= print >> return ""
ghci> :def date date
ghci> :date
2017-04-10 12:34:56.93213581 UTC

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

ghci> let mycd d = System.Directory.setCurrentDirectory d >> return ""
ghci> :def mycd mycd
ghci> :mycd ..

Можно также определить простой способ вызвать «ghc --make Main» в текущем каталоге:

ghci> :def make (\_ -> return ":! ghc --make Main")

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

ghci> :def . readFile
ghci> :. cmds.ghci

Обратите внимание, что мы назвали команду :. по аналогии с одноимённой командой оболочки Unix «.», выполняющей ту же задачу.

Если ввести :def без аргументов, будет выведен список определённых макросов. Попытка повторно определить существующую команду приводит к ошибке, если не используется форма :def!; в этом случае старая команда с таким именем заменяется без предупреждения. Однако встроенную команду по-прежнему можно вызвать, поставив перед её именем двойное двоеточие (например, ::load). Переопределить команды :{, :} и :! нельзя.

:delete * | ⟨num⟩ ...

Удаляет одну или несколько точек останова по номеру (чтобы узнать номера точек останова, используйте :show breaks). Форма * удаляет все точки останова.

:disable * | ⟨num⟩ ...

Отключает одну или несколько точек останова по номеру (чтобы узнать номер и состояние каждой точки останова, используйте :show breaks). Форма * отключает все точки останова.

:doc ⟨name⟩

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

:edit ⟨file⟩

Открывает редактор для файла ⟨file⟩ или, если ⟨file⟩ не указан, для последнего загруженного модуля. Если при последней загрузке возникли ошибки, курсор будет установлен на строку первой ошибки. Редактор выбирается из переменных окружения VISUAL или EDITOR; если ни одна из них не задана, используется редактор по умолчанию в системе. Изменить редактор можно с помощью команды :set editor.

VISUAL

Скрытая:

:enable * | ⟨num⟩ ...

Включает одну или несколько отключённых точек останова по номеру (чтобы узнать номер и состояние каждой точки останова, используйте :show breaks). Форма * включает все отключённые точки останова. При включении точки останова её ignore count сбрасывается в 0. (См. :ignore.)

:force ⟨identifier⟩ ...

Выводит значение ⟨identifier⟩ так же, как команда :print. В отличие от :print, команда :force вычисляет каждую встреченную при обходе значения thunk-структуру. Это может привести к исключениям, бесконечным циклам или новым точкам останова (они игнорируются, но отображаются).

:forward ⟨n⟩

Перемещается вперёд на ⟨n⟩ шагов по истории. Если ⟨n⟩ не указано, оно равно единице. Подробнее о средствах отладки GHCi см. в разделе Трассировка и история. См. также: :trace, :history, :back.

:help

:?

Показывает список доступных команд.

:

Повторяет предыдущую команду.

:history [num]

Показывает историю шагов вычисления. Если указано число, выводится соответствующее количество шагов (по умолчанию: 20). Используется вместе с командой :trace; см. раздел Трассировка и история. Чтобы задать число записей истории, хранящихся в GHCi, используйте флаг -fghci-hist-size=⟨n⟩.

:info[!] ⟨name⟩

Показывает информацию об указанном имени или именах. Например, если ⟨name⟩ — это класс, будут выведены методы класса и их типы; если ⟨name⟩ — конструктор типа, будет выведено его определение; если ⟨name⟩ — функция, будет выведен её тип. Если ⟨name⟩ загружено из исходного файла, GHCi также покажет расположение его определения в исходном коде.

GHCi выводит объявления типов (синонимы типов, newtype и типы данных, классы, семейства типов и данных) со значимыми с точки зрения семантики невидимыми связующими @.

Невидимый связующий считается значимым, если выполняется хотя бы один из следующих двух критериев:

• Он явно встречается в теле объявления
• За ним следует значимый связующий, поэтому он влияет на позицию

Для объявлений типов, не порождающих новые типы (синонимов типов и семейств типов), действует ещё один критерий:

• За ним не следует видимый связующий, поэтому он влияет на арность объявления типа

Для типов и классов GHCi также приводит сводку экземпляров, в которых они упоминаются. Чтобы не показывать лишнюю информацию, экземпляр отображается, только если (a) его заголовок содержит ⟨name⟩ и (b) все остальные сущности, упомянутые в экземпляре, доступны в области видимости (с квалификатором или без него) в результате выполнения команд :load или :module.

Команда :info! работает аналогично, но снимает ограничение (b), показывая все доступные в области видимости экземпляры, в заголовке которых упоминается ⟨name⟩.

:instances ⟨type⟩

Показывает все экземпляры классов, доступные для аргумента ⟨type⟩. Команда сопоставляет ⟨type⟩ с первым параметром каждого экземпляра, а затем проверяет, что все ограничения выполнимы.

В сочетании с расширением PartialTypeSignatures пользователь может вставлять подстановочные знаки в запрос и узнавать ограничения, которым должен удовлетворять каждый подстановочный знак, чтобы ⟨type⟩ соответствовал экземпляру.

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

Например:

> :instances Maybe (Maybe Int)
instance Eq (Maybe (Maybe Int)) -- Defined in ‘GHC.Maybe’
instance Ord (Maybe (Maybe Int)) -- Defined in ‘GHC.Maybe’
instance Show (Maybe (Maybe Int)) -- Defined in ‘GHC.Show’
instance Read (Maybe (Maybe Int)) -- Defined in ‘GHC.Read’

> :set -XPartialTypeSignatures -fno-warn-partial-type-signatures

> :instances Maybe _
instance Eq _ => Eq (Maybe _) -- Defined in ‘GHC.Maybe’
instance Semigroup _ => Monoid (Maybe _) -- Defined in ‘GHC.Base’
instance Ord _ => Ord (Maybe _) -- Defined in ‘GHC.Maybe’
instance Semigroup _ => Semigroup (Maybe _) -- Defined in ‘GHC.Base’
instance Show _ => Show (Maybe _) -- Defined in ‘GHC.Show’
instance Read _ => Read (Maybe _) -- Defined in ‘GHC.Read’

В результатах отображаются только экземпляры, которые потенциально можно использовать. Экземпляры, для которых требуются невыполнимые ограничения, например TypeError, не включаются. В следующем примере экземпляр для A не отображается, поскольку его нельзя использовать.

ghci>:set -XDataKinds -XUndecidableInstances
ghci>import GHC.TypeLits
ghci>class A a
ghci>instance (TypeError (Text "Not possible")) => A Bool
ghci>:instances Bool
instance Eq Bool -- Defined in ‘GHC.Classes’
instance Ord Bool -- Defined in ‘GHC.Classes’
instance Enum Bool -- Defined in ‘GHC.Enum’
instance Show Bool -- Defined in ‘GHC.Show’
instance Read Bool -- Defined in ‘GHC.Read’
instance Bounded Bool -- Defined in ‘GHC.Enum’

:issafe [⟨module⟩]

Показывает сведения Safe Haskell об указанном модуле (или о текущем модуле, если аргумент не указан). Сюда входят тип доверия модуля и содержащего его пакета.

:ignore ⟨break⟩ ⟨ignoreCount⟩

Задаёт счётчик пропуска для точки останова с номером ⟨break⟩, равный ⟨ignoreCount⟩.

В следующие ⟨ignoreCount⟩ раз, когда программа достигнет точки останова ⟨break⟩, эта точка останова будет пропущена, и программа не остановится. При каждом пропуске точки останова значение ignore count уменьшается на 1. Когда значение ignore count станет равным нулю, программа снова будет останавливаться в этой точке.

Также можно указать ⟨ignoreCount⟩ в команде :continue при возобновлении выполнения программы.

:kind[!] ⟨type⟩

Выводит выведенный вид ⟨type⟩. Последний может быть произвольным выражением типа, в том числе частичным применением конструктора типа, например Either Int. Более того, команда :kind позволяет записывать даже частичное применение синонима типа (обычно это запрещено), поэтому работает следующий пример:

ghci> type T a b = (a,b,a)
ghci> :k T Int Bool
T Int Bool :: *
ghci> :k T
T :: * -> * -> *
ghci> :k T Int
T Int :: * -> *

Свободные переменные типа также неявно квантифицируются, как если бы вы написали :k forall a. [a], поэтому работает и такой пример:

ghci> :k [a]
[a] :: *

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

:list ⟨identifier⟩

Показывает исходный код вокруг определения ⟨identifier⟩ или текущей точки останова, если идентификатор не указан. Идентификатор должен быть определён в интерпретируемом модуле. Если устройство вывода поддерживает это, GHCi выделит активное подвыражение жирным шрифтом.

:list [⟨module⟩] ⟨line⟩

Показывает исходный код вокруг указанного номера строки модуля ⟨module⟩. Модуль должен быть интерпретируемым. Если устройство вывода поддерживает это, GHCi выделит активное подвыражение жирным шрифтом.

:load[!] [*]⟨module⟩

Рекурсивно загружает указанные модули ⟨module⟩ и все модули, от которых они зависят. Здесь каждый ⟨module⟩ должен быть именем модуля или именем файла, но не может быть именем модуля из пакета.

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

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

Добавление необязательного параметра «!» превращает ошибки типов в предупреждения при загрузке. Это позволяет использовать корректные части модуля, даже если в некоторых определениях есть ошибки типов. Фактически перед загрузкой устанавливается флаг -fdefer-type-errors, а после загрузки он снимается, если не был установлен ранее. Дополнительные сведения и объяснение назначения см. в разделе Откладывание ошибок типов до времени выполнения.

После команды :load текущий контекст задаётся следующим образом:

• ⟨module⟩, если он успешно загружен;
• последний успешно загруженный модуль, если в результате выполнения текущей команды :load были загружены какие-либо другие модули;
• Prelude в противном случае.

:loc-at ⟨module⟩ ⟨line⟩ ⟨col⟩ ⟨end-line⟩ ⟨end-col⟩ [⟨name⟩]

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

X> :loc-at X.hs 6 14 6 16 mu
X.hs:(8,7)-(8,9)

Эта команда полезна при интеграции GHCi с текстовыми редакторами и IDE для реализации перехода к определению.

Для команды :loc-at необходимо включить :set +c.

:main ⟨arg1⟩ ... ⟨argn⟩

При компиляции и запуске программы для доступа к аргументам командной строки можно использовать действие ввода-вывода getArgs. Однако при тестировании в ghci нельзя просто передать аргументы в main, поскольку main не принимает их напрямую.

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

ghci> main = System.Environment.getArgs >>= print
ghci> :main foo bar
["foo","bar"]

Можно также заключать в кавычки аргументы, содержащие такие символы, как пробелы; они будут обрабатываться как строки Haskell. Или можно просто использовать синтаксис списков Haskell:

ghci> :main foo "bar baz"
["foo","bar baz"]
ghci> :main ["foo", "bar baz"]
["foo","bar baz"]

Наконец, другие действия ввода-вывода можно вызвать с флагом -main-is или с помощью команды :run:

ghci> foo = putStrLn "foo" >> System.Environment.getArgs >>= print
ghci> bar = putStrLn "bar" >> System.Environment.getArgs >>= print
ghci> :set -main-is foo
ghci> :main foo "bar baz"
foo
["foo","bar baz"]
ghci> :run bar ["foo", "bar baz"]
bar
["foo","bar baz"]

:module +|- [*]⟨mod1⟩ ...

import ⟨mod⟩

Задаёт или изменяет текущий контекст для инструкций, вводимых в приглашении. Форма import mod эквивалентна :module +mod. Дополнительные сведения см. в разделе Что на самом деле доступно в области видимости в приглашении?.

:print ⟨names⟩

Выводит значение, не вызывая его вычисления. Команду :print можно использовать для значений с неизвестными или частично известными типами, что может происходить с локальными переменными полиморфных типов в точке останова. При проверке значения во время выполнения :print пытается восстановить его тип и, если возможно, развернуть этот тип в окружении GHCi. Если встречаются невычисленные компоненты (thunk-структуры), :print связывает с каждой такой структурой новую переменную, имя которой начинается с _t. Дополнительные сведения см. в разделе Точки останова и проверка переменных. См. также команду :sprint, которая работает как :print, но не связывает новые переменные.

:quit

Завершает работу GHCi. Также можно выйти, введя в приглашении Control-D.

:reload[!] [none | ⟨mod1⟩ ...]

Пытается перезагрузить текущий набор целей (см. :load), если изменился какой-либо модуль в наборе или модуль, от которого он зависит. Обратите внимание: при этом могут загружаться новые модули или выгружаться модули, которые больше не требуются косвенным образом целям.

Добавление необязательного параметра «!» превращает ошибки типов в предупреждения при загрузке. Это позволяет использовать корректные части модуля, даже если в некоторых определениях есть ошибки типов. Фактически перед загрузкой устанавливается флаг -fdefer-type-errors, а после загрузки он снимается, если не был установлен ранее. Дополнительные сведения и объяснение назначения см. в разделе Откладывание ошибок типов до времени выполнения.

Если в качестве цели указано имя модуля, GHCi загрузит все модули графа модулей вплоть до указанного имени модуля ⟨mod1⟩. Если указано несколько имён целей, будут загружены все целевые модули. Чтобы выгрузить все текущие загруженные цели, укажите цель none.

:run

См. :main.

:script [⟨n⟩] ⟨filename⟩

Выполняет строки файла как последовательность команд GHCi. Синтаксис аргументов с именами файлов соответствует правилам экранирования оболочки: имена файлов с пробелами можно заключить в двойные кавычки или экранировать пробелы обратной косой чертой. Эта команда совместима с многострочными инструкциями, включёнными с помощью :set +m.

:set [⟨option⟩ ...]

Задаёт различные параметры. Список доступных параметров см. в разделе Команды :set и :seti, а список флагов, относящихся к GHCi, — в разделе Параметры интерактивного режима. Если вызвать команду :set без аргументов, она покажет установленные в данный момент параметры. Также она выводит текущие значения динамических флагов, отдельно перечисляя флаги GHCi.

:set args ⟨arg⟩

Задаёт список аргументов, возвращаемых при вызове программой System.Environment.getArgs.

:set editor ⟨cmd⟩

Задаёт команду ⟨cmd⟩, используемую командой :edit.

:set local-config ⟨source|ignore⟩

Если задано ignore, файлы ./.ghci будут игнорироваться (загрузка недоверенных локальных скриптов представляет угрозу безопасности). По умолчанию используется source. Задайте эту директиву в пользовательском скрипте .ghci, то есть до загрузки локального скрипта.

Даже если задано ignore, локальный скрипт всё равно будет обработан, если он указан в командной строке с помощью -ghci-script или загружен командой :script.

:set prog ⟨prog⟩

Задаёт строку, возвращаемую при вызове программой System.Environment.getProgName.

:set prompt ⟨prompt⟩

Задаёт строку, используемую в качестве приглашения в GHCi. Внутри ⟨prompt⟩ следующие последовательности заменяются:

• %s именами модулей, которые в данный момент находятся в области видимости.
• %l номером строки (на который ссылаются сообщения компилятора) текущего приглашения.
• %d датой в формате «день недели, месяц, число» (например, «Вт, 26 мая»).
• %t текущим временем в 24-часовом формате ЧЧ:ММ:СС.
• %T текущим временем в 12-часовом формате ЧЧ:ММ:СС.
• %@ текущим временем в 12-часовом формате с указанием AM/PM.
• %A текущим временем в 24-часовом формате ЧЧ:ММ.
• %u именем текущего пользователя.
• %w текущим рабочим каталогом.
• %o операционной системой.
• %a архитектурой компьютера.
• %N именем компилятора.
• %V версией компилятора.
• %call(cmd [args]) результатом вызова cmd args.
• %% значением %.

Если ⟨prompt⟩ начинается с ", он разбирается как строка Haskell; в противном случае он воспринимается как строка литерала.

:set prompt-cont ⟨prompt⟩

Задаёт строку, используемую в качестве приглашения продолжения в GHCi (оно используется при выполнении команды :{).

:set prompt-function ⟨prompt-function⟩

Задаёт функцию, используемую для отображения приглашения в GHCi. Функция должна иметь тип [String] -> Int -> IO String. Эта функция вызывается каждый раз при формировании приглашения. Первый аргумент содержит имена модулей, которые в данный момент находятся в области видимости (имя «самого верхнего» модуля будет начинаться с *; дополнительную информацию см. в разделе Что на самом деле находится в области видимости в приглашении?). Второй аргумент — номер строки (на который ссылаются сообщения компилятора) текущего приглашения.

:set prompt-cont-function ⟨prompt-function⟩

Задаёт функцию, используемую для отображения приглашения продолжения в GHCi (оно используется при выполнении команды :{).

:set stop ⟨num⟩ ⟨cmd⟩

Задаёт команду, которая выполняется при срабатывании точки останова или выборе нового элемента в истории. Наиболее распространённое применение команды :set stop — отображение исходного кода в текущей позиции, например :set stop :list.

Если перед командой указано число, команды выполняются только при срабатывании указанной точки останова. Это может быть весьма полезно: например, :set stop 1 :continue фактически отключает точку останова 1, выполняя :continue при каждом её срабатывании. В этом случае GHCi всё равно выведет сообщение о срабатывании точки останова. Если такое сообщение не нужно, можно использовать команду :disable. Кроме того, при умелом использовании :def и :cmd можно применять :set stop для реализации условных точек останова:

*ghci> :def cond \expr -> return (":cmd if (" ++ expr ++ ") then return \"\" else return \":continue\"")
*ghci> :set stop 0 :cond (x < 3)

Чтобы игнорировать точки останова заданное число итераций, используйте команду :ignore или параметр ⟨ignoreCount⟩ команды :continue.

:seti [⟨option⟩ ...]

Подобно :set, но параметры, заданные с помощью :seti, влияют только на выражения и команды, введённые в приглашении, но не на модули, загруженные с помощью :load (в отличие от этого, параметры, заданные с помощью :set, применяются повсюду). См. раздел Настройка параметров только для интерактивного вычисления.

Если аргументы не указаны, отображается текущий набор параметров, применяемых к выражениям и командам, введённым в приглашении.

:show bindings

Показывает определения, созданные в приглашении, и их типы.

:show breaks

Выводит список активных точек останова.

:show context

Выводит список активных вычислений, остановленных на точках останова.

:show imports

Показывает импорты, действующие в данный момент и созданные командами import и :module.

:show modules

Показывает список загруженных в данный момент модулей.

:show packages

Показывает активные в данный момент флаги пакетов, а также список загруженных пакетов.

:show paths

Показывает текущий рабочий каталог (заданный командой :cd), а также список каталогов, в которых выполняется поиск исходных файлов (задаётся параметром -i).

:show language

Показывает активные в данный момент языковые флаги для исходных файлов.

:showi language

Показывает активные в данный момент языковые флаги для выражений, введённых в приглашении (см. также :seti).

:show targets

Показывает список загруженных в данный момент модулей. Этот набор загруженных модулей можно изменить с помощью команд :load, :reload, :add и :unadd.

:show [args|prog|prompt|editor|stop]

Показывает указанную настройку (см. :set).

:sprint ⟨expr⟩

Выводит значение, не запуская его вычисление. Команда :sprint похожа на :print, но невычисленные подвыражения не связываются с новыми переменными, а просто обозначаются как _.

:step [⟨expr⟩]

Включает все точки останова и начинает пошаговое вычисление выражения. В этом режиме вычисление останавливается после каждой редукции, позволяя просматривать локальные переменные. Если ⟨expr⟩ не задано, вычисление продолжится с последней точки останова. См. раздел Пошаговое выполнение.

:steplocal

Включает только точки останова в текущем связывании верхнего уровня и продолжает вычисление с последней точки останова. Продолжить выполнение с помощью :steplocal невозможно, если эта последняя точка останова сработала из-за ошибки (-fbreak-on-error) или исключения (-fbreak-on-exception).

:stepout

Начиная с:

9.14.1

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

Известные ограничения: поскольку хвостовой вызов функции не помещает кадр в стек, при выполнении команды step-out внутри функции, вызванной хвостовым вызовом, выполнение вернётся не к её вызывающей функции, а к первому вызывающему контексту, который не является хвостовым. С другой стороны, это означает, что отладчик следует более реалистичному ходу выполнения программы. В следующем примере:

f = do

a b <— (1) установите точку останова, затем выполните переход сюда c

b = do

… d <— (2) выполните переход внутрь этого хвостового вызова

d = do

… something <— (3) выполните выход отсюда …

При пошаговом выходе выполнение остановится на вызове c в f, а не на b.

:stepmodule

Включает только точки останова в текущем модуле и продолжает вычисление с последней точки останова.

:trace ⟨expr⟩

Вычисляет заданное выражение (или продолжает с последней точки останова, если выражение не задано), а также записывает шаги вычисления для последующего просмотра с помощью :history. См. раздел Трассировка и история.

:type ⟨expression⟩

Выводит тип ⟨expression⟩, разрешая ограничения и сводя семейства типов насколько возможно. Для полиморфных типов не выполняется инстанцирование переменных, квантифицированных forall.

*X> :type length
length :: Foldable t => t a -> Int

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

:type +d ⟨expression⟩

Выводит тип ⟨expression⟩, инстанцируя все кванторы forall, разрешая ограничения, выполняя подстановку значений по умолчанию и обобщение. В этом режиме, если на выведенный тип накладывает ограничения какой-либо интерактивный класс (Num, Show, Eq, Ord, Foldable или Traversable), для ограниченных переменных типа подставляются значения по умолчанию согласно правилам, описанным в разделе ExtendedDefaultRules. Этот режим весьма полезен, когда выведенный тип достаточно общий (например, для foldr) и может быть полезно увидеть более конкретную инстанциацию.

*X> :type +d length
length :: [a] -> Int

:type-at ⟨path⟩ ⟨line⟩ ⟨col⟩ ⟨end-line⟩ ⟨end-col⟩ [⟨name⟩]

Сообщает выведенный тип в заданном диапазоне/позиции модуля, например:

*X> :type-at X.hs 6 6 6 7 f
Int -> Int

Эта команда полезна при интеграции GHCi с текстовыми редакторами и IDE для реализации функции отображения типа в позиции курсора.

Первый параметр (путь) должен быть путём к файлу, а не именем модуля. Тип этого пути зависит от способа загрузки модуля в GHCi: если модуль был загружен по имени, необходимо использовать имя пути, вычисленное GHCi, как описано в разделе Модули и имена файлов. Если модуль был загружен по абсолютному или относительному пути, необходимо указать тот же путь.

Последний строковый параметр полезен, если диапазон устарел, то есть файл изменился и код переместился. В этом случае :type-at переключается на общий поиск, подобный :type.

Для команды :type-at необходимо установить :set +c.

:unadd ⟨module⟩

Удаляет ⟨module⟩(s) из текущего набора целей и выполняет перезагрузку (см. выше :add).

:undef ⟨name⟩

Удаляет пользовательскую команду ⟨name⟩ (см. выше :def).

:unset ⟨option⟩

Сбрасывает некоторые параметры. Список доступных параметров см. в разделе Команды :set и :seti.

:uses ⟨module⟩ ⟨line⟩ ⟨col⟩ ⟨end-line⟩ ⟨end-col⟩ [⟨name⟩]

Сообщает обо всех локальных для модуля использованиях элемента в указанной позиции модуля, например:

:uses GhciFind.hs 53 66 53 70 name
GhciFind.hs:(46,25)-(46,29)
GhciFind.hs:(47,37)-(47,41)
GhciFind.hs:(53,66)-(53,70)
GhciFind.hs:(57,62)-(57,66)

Эта команда полезна для выделения и перехода ко всем использованиям идентификатора в редакторах и IDE.

Для команды :uses необходимо установить :set +c.

:where

Показывает текущий стек вычисления, когда выполнение остановлено на точке останова.

:: ⟨builtin-command⟩

Выполняет встроенную команду GHCi (например, ::type 3). То есть ищет команду в списке встроенных команд, исключая определённые макросы. См. также: :def.

:! ⟨command⟩

Выполняет команду оболочки ⟨command⟩.

3.8. Команды :set и :seti

Команда :set задаёт два типа параметров: параметры GHCi, начинающиеся с «+», и параметры «командной строки», начинающиеся с «-».

ghci> :set -Wmissing-signatures

ghci> {-# OPTIONS_GHC -Wmissing-signatures #-}

ghci> :set -Wno-incomplete-patterns -XNoMultiParamTypeClasses

:seti -XMonoLocalBinds

ghci> :seti
base language is: GHC2021
with the following modifiers:
  -XExtendedDefaultRules
  -XNoMonomorphismRestriction
GHCi-specific dynamic flag settings:
other dynamic, non-language, flag settings:
  -fexternal-dynamic-refs
  -fignore-optim-changes
  -fignore-hpc-changes
  -fimplicit-import-qualified
warning settings:

3.9. Файлы .ghci и .haskeline

:set -XMultiParamTypeClasses -XScopedTypeVariables -cpp
:set -iA:B:C

:def source readFile

3.10. Компиляция в объектный код внутри GHCi

По умолчанию GHCi компилирует исходный код на Haskell в байт-код, который интерпретируется системой времени выполнения. GHCi также может компилировать код на Haskell в объектный код: чтобы включить эту возможность, используйте флаг -fobject-code в командной строке или с помощью :set (параметр -fbyte-code снова включает компиляцию в байт-код). Компиляция в объектный код занимает больше времени, но обычно такой код выполняется в 10–20 раз быстрее байт-кода.

Компиляция в объектный код внутри GHCi особенно полезна при разработке компилируемого приложения, поскольку команда :reload обычно выполняется намного быстрее, чем перезапуск GHC с параметром --make из командной строки: все файлы интерфейсов уже находятся в кэше памяти.

У компиляции в объектный код есть и недостатки: например, в модулях объектного кода нельзя устанавливать точки останова. В GHCi будут видны только экспорты модуля объектного кода, а не все привязки верхнего уровня, как в интерпретируемых модулях.

3.11. Запуск интерпретатора в отдельном процессе

Обычно GHCi запускает интерпретируемый код в том же процессе, что и сам GHC, используя ту же RTS и общую кучу. Однако, если задан флаг -fexternal-interpreter, GHC создаст отдельный процесс для выполнения интерпретируемого кода и будет обмениваться с ним сообщениями через канал.

-fexternal-interpreter

Начиная с версии:

8.0.1

Выполнять интерпретируемый код (для GHCi, Template Haskell, квазицитирования или аннотаций) в отдельном процессе. Интерпретатор будет работать в режиме профилирования, если активен -prof, и в режиме динамической компоновки, если активен -dynamic.

Есть несколько ограничений, которые, как мы надеемся, будут устранены в будущем: сейчас этот параметр не реализован в Windows (он ничего не делает), а внешний интерпретатор не поддерживает отладчик GHCi, поэтому точки останова и пошаговое выполнение не работают с -fexternal-interpreter.

См. также флаги -pgmi ⟨cmd⟩ (Замена программы для одной или нескольких фаз) и -opti ⟨option⟩ (Передача параметров конкретной фазе).

Зачем это нужно? Главная причина в том, что RTS, выполняющая интерпретируемый код, может отличаться от RTS самого GHC (например, поддерживать профилирование или динамическую компоновку). Например:

• При использовании GHCi можно собирать трассировки стека с помощью профилировщика (см. Трассировки стека в GHCi).
• При компиляции кода Template Haskell с флагом -prof больше не нужно сначала компилировать модули без -prof (см. Использование Template Haskell с профилированием), поскольку профилированный объектный код можно выполнить в интерпретаторе.

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

#include <RtsSymbols.h>

#define CODE_SYM(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
                      (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_CODE },
#define DATA_SYM(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
                      (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_DATA },

RtsSymbolVal my_iserv_syms[] = {
    CODE_SYM(malloc)
    CODE_SYM(getauxval)
    CODE_SYM(posix_spawn_file_actions_init)
    ...
    { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE } /* sentinel */
};

RtsSymbolVal* rtsExtraSyms() {
    return my_iserv_syms;
}

3.12. Сборка библиотек GHCi

При статическом запуске GHCi использует статический компоновщик времени выполнения GHC RTS для загрузки объектных файлов импортированных модулей, если они доступны. Однако, если эти модули собраны с флагом -split-sections, такая компоновка может быть довольно затратной. Чтобы сократить эти затраты, менеджеры пакетов и системы сборки могут создавать предварительно скомпонованный объект GHCi в режиме --merge-objs. В этом режиме объектные файлы отдельных модулей объединяются в один объект, а секции функций сворачиваются в единую текстовую секцию, которую компоновщик времени выполнения может эффективно загрузить.

3.13. Часто задаваемые вопросы и важные замечания

Интерпретатор не может загружать модули с объявлениями foreign export!

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

Параметр -O не действует в GHCi!

До GHC 9.8 оптимизации считались слишком нестабильными для использования с интерпретатором байт-кода. Это ограничение снято, однако возможность по-прежнему считается экспериментальной и управляется флагом -funoptimized-core-for-interpreter, включённым по умолчанию. Чтобы использовать оптимизации, выполните:

ghci -fno-unoptimized-core-for-interpreter -O

Параллельные потоки не продолжают работу, пока GHCi ожидает ввода.

Это должно работать, если ваша сборка GHCi выполнена с параметром -threaded, используемым по умолчанию. Обратитесь к поставщику вашей установки GHCi.

After using getContents, I can’t use stdin, until I do :load or :reload

Таково определённое поведение getContents: он переводит дескриптор stdin в состояние, называемое полуоткрытым, в котором дальнейшие операции ввода-вывода с ним запрещены. Поскольку состояние ввода-вывода сохраняется между вычислениями, это состояние сохраняется до следующей команды :load или :reload.

Можно настроить stdin так, чтобы он сбрасывался после каждого вычисления: для этого передайте GHCi команду :set +r. Это работает, поскольку stdin — всего лишь выражение верхнего уровня, которое можно вернуть в нев вычисленное состояние так же, как и любое другое выражение верхнего уровня (CAF).

В Windows я не могу использовать Control-C, чтобы прервать вычисления в GHCi.

См. раздел Запуск GHCi в Windows.

Режим буферизации по умолчанию в GHCi отличается от GHC.

В GHC дескриптор stdout по умолчанию буферизуется построчно. Однако в GHCi буферизация stdout отключена, поскольку для интерпретатора обычно предпочтительно, чтобы вывод появлялся по мере его формирования.

Если вам нужна построчная буферизация, как в GHC, можно запустить программу следующим образом:

main = do { hSetBuffering stdout LineBuffering; ... }