Ru/IO
Функции и процедуры
В императивных языках вроде C++ нет разделения функций на чистые и имеющие побочные эффекты, любая функция рассматривается как потенциально "грязная". С одной стороны, это облегчает модификацию программы (к любой чисто вычислительной функции могут быть добавлены побочные эффекты), с другой стороны - усложняет понимание программы, её отладку и модификацию. Какая-нибудь скромная функция sin может иметь совершенно нескромные побочные эффекты, например стереть системные файлы.
В отличие от них, в Haskell все функции чётко поделены на два класса. Для удобства дальнейшего изложения давайте условимся называть чистые функции просто функциями, а нечистые - процедурами. Итак, функция - это просто однозначный способ вычисления выходного значения по входным, а процедура выполняет некоторое действие (хотя может иметь и выходное значение).
Вычисления внутри функций производятся по мере необходимости и в том порядке, в каком в них возникает необходимость. В отличие от этого процедура описывает последовательность операций, которые выполняются обязательно и обязательно в указанном порядке. Поэтому способ записи, применяемый для определения функций, не годится для процедур, и для них используется специальная do-нотация, сходная с императивными языками (как С++ или Python).
Функции не могут вызывать процедуры, и это означает, что Haskell гарантирует отсутствие побочных эффектов в чистых вычислениях. По своему опыту могу сказать, что в первое время программировать с этим ограничением было неудобно, но потом привыкаешь и начинаешь просто думать по-другому, автоматически разделяя в уме алгоритмы чистых вычислений и императивную логику программы с тем, чтобы записать их отдельно друг от друга.
Описание процедур
Главная выполняемая функция в программе на Haskell - main - является процедурой, и на ней мы рассмотрим примеры описания процедур.
Простейшая процедура, выполняющая два действия. Как мы уже говорили, они выполняются строго в заданном порядке:
main = do print "Zdravstvuj, mir, eto ja!"
print "Haskell zzhot, C++ ...!"
"Действия", выполнямые в do - это в свою очередь вызовы других процедур. Мы также можем присваивать "переменным" значения, возвращаемые из этих процедур, и организовывать условное выполнение:
main = do print "Ej, parenj, kak tebja zvatj-to?"
name <- getLine
if name=="Bulat"
then do print "Blagodarju, Sozdatelj"
else do print ("Zdorovo, " ++ name)
Аналогичным образом можно применять и case:
main = do print "Ej, parenj, kak tebja zvatj-to?"
name <- getLine
case name of "Bulat" -> do print "Blagodarju, Sozdatelj"
"Deniok" -> do print "Blagodarju, Kosozdatelj"
_ -> do print ("Zdorovo, " ++ name)
Для организации циклов, как обычно, используется хвостовая рекурсия. Например, эта программа печатает числа от 1 до 10:
main = do printRec 1
printRec 10 = print 10
printRec i = do print i
printRec (i+1)
Для возврата результата из процедуры используется return. Опишем рекурсивную процедуру, которая дожидается ввода непустой строки:
myGetLine = do str <- getLine
if str==""
then do print "Pozhalujsta, vvedite nepustuju stroku"
str <- myGetLine
return str
else do return str
и пример её применения:
main = do print "Ej, parenj, kak tebja zvatj-to?"
name <- myGetLine
if name=="Bulat"
then do print "Blagodariu, Sozdatelj"
else do print ("Zdorovo, " ++ name)
Совершенно аналогично функциям, процедуры могут иметь входные параметры. Для описания чистых вычислений внутри процедур можно использовать let-блоки, однако вычисления в let-блоке не могут ссылаться на имена, определённые в нижеследующих действиях или let-блоках:
math x y = do
let x2 = x*2
x3 = x2*x
xy = x*y
print ("x=" ++ (show x))
print ("x v kvadrate=" ++ (show x2))
print ("x v kube=" ++ (show x3))
print ("proizvedenie x i y=" ++ (show xy))
main = do math 2 2
math 3 4
А теперь забацаем пример, который включает все вышеприведённые извраты:
...
Процедуры ввода/вывода
Для начала скажем, что типы процедур описываются точно так же, как и типы функций, только к типу результата добавляется IO. Если процедуре нечего возвратить, то используется тип результата IO (). Говоря высоким штилем, процедура - это обычная функция, возвращающая результат в монаде IO.
Теперь опишем процедуры интерфейса с пользователем:
putChar :: Char -> IO () -- выводит один символ на stdout
putStr :: String -> IO () -- выводит строку на stdout
putStrLn :: String -> IO () -- выводит строку на stdout и добавляет от себя перевод каретки
print :: (Show a) => a -> IO () -- печатает любое значение, 'print x = putStrLn (show x)'
getChar :: IO Char -- читает один символ с stdin
getLine :: IO String -- читает одну строку с stdin
getContents :: IO String -- читает всё содержимое stdin и возвращает его
-- как одну большую строку с '\n' в качестве разделителя
readLn :: (Read a) => IO a -- читает значение любого типа
Продвинутые возможности описания процедур
здесь будут описаны циклы внутри процедур, return из середины процедуры, возврат значения из if/case, результат последнего вызова как результат всей процедуры, типы процедур и отличие действий (IO a) от процедур (x->y->...->IO a), использование >> и >>=
Процедуры как значения первого класса (first-class values)
Наконец, давайте вернёмся к истокам и вспомним, что "процедуры" в хаскеле - это всего лишь функции, которые могут иметь побочные эффекты, а функции в хаскеле являются "первоклассными" значениями. Это значит, что процедуры, как и любые другие функции, можно передавать в качестве параметров, сохранять в структурах данных, "добивать" параметрами и т.д. Различие всего одно - функция, применённая ко всем своим параметрами, является уже значением - это значение может храниться невычисленным только благодаря lazy evaluation. Процедура же, даже со всеми своими параметрами, остаётся процедурой (или если хотите действием) и выполняется ровно в тот момент, когда она вызвана в do-нотации. Пример:
main = do example (print "Privet!!")
example action = do print "Do.."
action
print "Posle.."
Здесь "Привет!!" печатается не в момент вызова example (для него операция печати - это всего лишь пассивный параметр), а в тот момент, когда вызов action вставлен в do-последовательность.
Немного глубже в do
Поначалу кажется, что do - какая-то чёрная магия, или встроенный синтаксис для записи процедур. На самом деле всё это просто cинтаксический сахар, без которого можно обойтись, но который позволяет склеивать процедуры и делает их написание проще. Но об этих тонкостях лучше прочитать в статье о монадах.
Библиотеки
Работа с файлами
- (english) Описание в Gentle Introduction
- (english) Описание в Tackling the Awkward Squad
Императивные массивы и хеши
- (english) Описание работы с иммутабельными массивами в Gentle Introduction
- (english) Описание в Modern array libraries
Обработка исключений (exceptions) и перехват сигналов ОС
- (english) Описание в Gentle Introduction
- (english) Описание в Tackling the Awkward Squad
Многопоточное программирование
- (english) Описание в Tackling the Awkward Squad
Пример:
Задача такова: коммуникационный сервер, с какой то периодичностью по очереди по одному COM порту читает два прибора. прочитанную информацию с этих приборов нужно к примеру записать в файл с меткой времени когда мы прочитали. и так по циклу... а таких COM портов (потоков) может быть несколько. и на каждом разное количество приборов... одновременно читать приборы нельзя. можно только по очереди... и все надо сохранить в файл как можно быстрее и читать как можно чаще одни типы данных, другие с жестко заданной периодичностью (http://rsdn.ru/Forum/message/2661238.flat.aspx)
main = do com <- replicateM 4 newMVar -- создаём 4 мьютекса для синхронизации работы с 4 компортами
files <- mapM ((`fileOpen` WriteMode).show) [0..9] -- создаём файлы с именами "0".."9" для записи данных
mapM_ (forkIO . service com files) -- запустим отдельный поток для обслуживания каждого прибора
[ (0, 0x48, 100, 0) -- список (номер ком-порта, адрес Modbus, частота сканирования, номер файла),
, (0, 0x88, 0, 1) -- описывающий откуда и с какой частотой читать данные и куда их записывать
...]
forever (threadDelay$ 10^6) -- бесконечный пустой цикл, что позволяет крутиться в фоне потокам обслуживания приборов
-- |Процедура потока, обслуживающего один прибор с заданными параметрами
service com files (port, addr, delay, filenum) = do
x <- withMVar (com!port) $ \_ -> do -- блокируем доступ других потоков к этому ком-порту
... -- читаем данные из ком-порта
hPutStrLn (files!filenum) x -- записываем данные в файл
threadDelay delay -- ожидаем заданное число микросекунд
service com files (port, addr, delay, filenum) -- хвостовая рекурсия используется для организации бесконечного цикла
STM (Software Transactional Memory) - новый способ многопоточного программирования
- (english) Всё об STM
Интерфейс с С и работа с памятью
- (english) Описание в Tackling the Awkward Squad
Ссылки
- (на русском)
- Основы функционального программирования/Операции ввода/вывода в Haskell'е
- Исходники FreeArc - большая императивная программа с обширными комментариями, где вы можете найти примеры организации многопоточности, интерфейса с С, работы с памятью, использования хещей, использования процедур в качестве параметров. Там же вы найдёте библиотеки для работы с файлами в Win32 (с поддержкой Unicode имён и размеров файлов >4гб), упакованными строками в UTF8-кодировке, организации многопоточной программы в стиле unix pipes, сериализации и упаковки данных
- (english)
- IO_inside рассказывает о внутреннем устройстве монады IO, приводит множество практических примеров императивного программирования в Haskell и содержит дополнительные ссылки
- Tackling the Awkward Squad описывает императивное программирование, взаимодействие с языком C, многопоточное программирование и обработку исключений (exceptions)