Действительно ли Haskell чист (какой-нибудь язык, который имеет дело с вводом и выводом вне системы)?

Возьмем следующий мини-язык:

data Action = Get (Char -> Action) | Put Char Action | End

Get f означает: прочитать символ c и выполнить действие f c.

Put c a означает: записать символ c, и выполнить действие a.

Вот программа, которая печатает "xy", затем запрашивает две буквы и печатает их в обратном порядке:

Put 'x' (Put 'y' (Get (\a -> Get (\b -> Put b (Put a End)))))

Вы можете манипулировать такими программами. Например:

conditionally p = Get (\a -> if a == 'Y' then p else End)

Эта имеет тип Action -> Action - она берет программу и дает другую программу, которая сначала запрашивает подтверждение. Вот еще:

printString = foldr Put End

This имеет тип String -> Action - он принимает строку и возвращает программу, которая записывает строку, например

Put 'h' (Put 'e' (Put 'l' (Put 'l' (Put 'o' End)))).

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

В языке типа C вы можете написать функцию void execute(Action a), которая фактически выполняет программу. В языке Haskell вы указываете это действие, написав main = a. Компилятор создает программу, которая выполняет действие, но у вас нет другого способа выполнить действие (кроме грязных трюков).

Очевидно, что Get и Put - это не только варианты, вы можете добавить множество других вызовов API к типу данных IO, например, работу с файлами или параллелизм.

Добавление значения результата

Теперь рассмотрим следующий тип данных.

data IO a = Get (Char -> Action) | Put Char Action | End a

Предыдущий тип Action эквивалентен IO (), то есть значению IO, которое всегда возвращает "единицу", сравнимую с "void".

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

Это действия IO, которые могут заканчиваться некоторым результатом. Значение вроде этого:

Get (\x -> if x == 'A' then Put 'B' (End 3) else End 4)

имеет тип IO Int и соответствует программе на C:

int f() {
  char x;
  scanf("%c", &x);
  if (x == 'A') {
    printf("B");
    return 3;
  } else return 4;
}

Оценка и выполнение

Есть разница между оценкой и выполнением. Вы можете оценить любое выражение Haskell и получить значение; например, оценить 2+2 :: Int в 4 :: Int. Выполнять выражения Haskell можно только те, которые имеют тип IO a. Это может иметь побочные эффекты; выполнение Put 'a' (End 3) выводит букву a на экран. Если вы оцените значение IO, например, так:

if 2+2 == 4 then Put 'A' (End 0) else Put 'B' (End 2)

вы получите:

Put 'A' (End 0)

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

Как бы вы перевели

bool comp(char x) {
  char y;
  scanf("%c", &y);
  if (x > y) {       //Character comparison
    printf(">");
    return true;
  } else {
    printf("<");
    return false;
  }
}

в значение IO?

Зафиксируйте некоторый символ, скажем, 'v'. Теперь comp('v') - это действие IO, которое сравнивает данный символ с 'v'. Аналогично, comp('b') - это действие ввода-вывода, которое сравнивает данный символ с 'b'. В общем, comp - это функция, которая принимает символ и возвращает действие ввода-вывода.

Как программист на языке Си, вы можете возразить, что comp('b') - это булево число. В Си оценка и выполнение идентичны (т.е. они означают одно и то же, или происходят одновременно). Не в Хаскеле. comp('b') оценивается в некоторое действие IO, которое после выполнения дает булево число. (Точнее, оно оценивается в блок кода как выше, только с 'b' вместо x.)

comp :: Char -> IO Bool
comp x = Get (\y -> if x > y then Put '>' (End True) else Put '<' (End False))

Теперь, comp 'b' оценивается в Get (\y -> if 'b' > y then Put '>' (End True) else Put '<' (End False)).

Это также имеет смысл с математической точки зрения. В языке C, int f() - это функция. Для математика это не имеет смысла - функция без аргументов? Смысл функций в том, чтобы принимать аргументы. Функция int f() должна быть эквивалентна int f. Это не так, потому что функции в C смешивают математические функции и действия ввода-вывода.

Первый класс

Эти значения IO являются первоклассными. Точно так же, как вы можете иметь список кортежей целых чисел [[(0,2),(8,3)],[(2,8)]], вы можете строить сложные значения с помощью IO.

 (Get (\x -> Put (toUpper x) (End 0)), Get (\x -> Put (toLower x) (End 0)))
   :: (IO Int, IO Int)

Кортеж действий IO: первый читает символ и печатает его в верхнем регистре, второй читает символ и возвращает его в нижнем регистре.

 Get (\x -> End (Put x (End 0))) :: IO (IO Int)

Значение IO, которое читает символ x и завершается, возвращая значение IO, которое записывает x на экран.

В Haskell есть специальные функции, которые позволяют легко манипулировать значениями IO. Например:

 sequence :: [IO a] -> IO [a]

которая принимает список IO-действий и возвращает IO-действие, которое выполняет их последовательно.

Монады

Монады - это некоторые комбинаторы (как условно выше), которые позволяют писать программы более структурно. Существует функция composes type

 IO a -> (a -> IO b) -> IO b

которая, учитывая IO a, и функцию a -> IO b, возвращает значение типа IO b. Если записать первый аргумент как функцию языка Си a f(), а второй аргумент как b g(a x), то получится программа для g(f(x)).. Учитывая приведенное выше определение Action / IO, вы можете написать эту функцию самостоятельно.

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

Чистота

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

В Haskell, если у вас есть f x+f x, вы можете заменить его на 2*f x. В Си f(x)+f(x) в общем случае не то же самое, что 2*f(x), поскольку f может напечатать что-то на экране или изменить x.

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