Изучай Haskell во имя добра! - Миран Липовача

doesntExist :: String -> [String] -> IO ()

doesntExist command _ =

   putStrLn $ "Команда " ++ command ++ " не определена"

Также можно добавить варианты определения функций add, view и remove для случаев, когда программе передано неправильное количество аргументов. Например:

add :: [String] -> IO ()

add [fileName, todoItem] = appendFile fileName (todoItem ++ "n")

add _ = putStrLn "Команда add принимает в точности два аргумента"

Если функция add будет применена к списку, содержащему не два элемента, первый образец не сработает, поэтому пользователю будет выведено сообщение об ошибке. Аналогично дописываются функции view и remove.

Заметьте, что мы не обрабатываем все возможные случаи некорректного ввода. К примеру, программа «упадёт», если мы запустим её так:

./todo

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

Случайность

Зачастую при программировании бывает необходимо получить некоторые случайные данные. Возможно, вы создаёте игру, где нужно бросать игральные кости, или генерируете тестовые данные, чтобы проверить вашу программу. Существует много применений случайным данным. На самом деле они, конечно, псевдослучайны – ведь мы-то с вами знаем, что настоящим примером случайности можно считать разве что пьяную обезьяну на одноколесном велосипеде, которая одной лапой хватается за собственный зад, а в другой держит сыр. В этой главе мы узнаем, как заставить язык Haskell генерировать вроде бы случайные данные (без сыра и велосипеда).

В большинстве языков программирования есть функции, которые возвращают некоторое случайное число. Каждый раз, когда вы вызываете такую функцию, вы (надеюсь) получаете новое случайное число. Ну а как в языке Haskell? Как мы помним, Haskell – чистый функциональный язык. Это означает, что он обладает свойством детерминированности. Выражается оно в том, что если функции дважды передать один и тот же аргумент, она должна дважды вернуть один и тот же результат. На самом деле это удобно, поскольку облегчает наши размышления о программах, а также позволяет отложить вычисление до тех пор, пока оно на самом деле не пригодится. Если я вызываю функцию, то могу быть уверен, что она не делает каких-либо темных делишек на стороне, прежде чем вернуть мне результат. Однако из-за этого получать случайные числа не так-то просто. Допустим, у меня есть такая функция:

randomNumber :: Int

randomNumber = 4

Она не очень-то полезна в качестве источника случайных чисел, потому что всегда возвращает 4, даже если я поклянусь, что эта четвёрка абсолютно случайная, так как я использовал игральную кость для определения этого числа!

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

Ага!.. Так же вы можете создавать случайные числа и в языке Haskell, если напишете функцию, которая принимает случайные величины как параметры и, основываясь на них, возвращает некоторое число (или другой тип данных).

Посмотрим на модуль System.Random. В нём содержатся функции, которые удовлетворят все наши нужды в отношении случайностей! Давайте посмотрим на одну из экспортируемых функций, а именно random. Вот её тип:

random :: (RandomGen g, Random a) => g –> (a, g)

Так! В декларации мы видим несколько новых классов типов. Класс типов RandomGen предназначен для типов, которые могут служить источниками случайности. Класс типов Random предназначен для типов, которые могут принимать случайные значения. Булевские значения могут быть случайными; это может быть True или False. Число может принимать огромное количество случайных значений. Может ли функция принимать случайное значение? Не думаю – скорее всего, нет! Если мы попытаемся перевести объявление функции random на русский язык, получится что-то вроде «функция принимает генератор случайности (источник случайности), возвращает случайное значение и новый генератор случайности». Зачем она возвращает новый генератор вместе со случайным значением?.. Увидим через минуту.

Чтобы воспользоваться функцией random, нам нужно получить один из генераторов случайности. Модуль System.Random экспортирует полезный тип StdGen, который имеет экземпляр класса RandomGen. Мы можем создать значение типа StdGen вручную или попросить систему выдать нам генератор, основывающийся на нескольких вроде бы случайных вещах.

Для того чтобы создать генератор вручную, используйте функцию mkStdGen. Её тип – mkStdGen :: Int –> StdGen. Он принимает целое число и основывается на нём, возвращая нам генератор. Давайте попробуем использовать функции random и mkStdGen, чтобы получить… сомнительно, что случайное число.

ghci> random (mkStdGen 100)

<interactive>:1:0:

   Ambiguous type variable `a' in the constraint:

     `Random a' arising from a use of `random' at <interactive>:1:0–20

   Probable fix: add a type signature that fixes these type variable(s)

Что это?… Ах, да, функция random может возвращать значения любого типа, который входит в класс типов Random, так что мы должны указать языку Haskell, какой тип мы желаем получить в результате. Также не будем забывать, что функция возвращает случайное значение и генератор в паре.

ghci> random (mkStdGen 100) :: (Int, StdGen)

(–1352021624,651872571 1655838864)

Ну наконец-то! Число выглядит довольно-таки случайным. Первый компонент кортежа – это случайное число, второй элемент – текстовое представление нового генератора. Что случится, если мы вызовем функцию random с тем же генератором снова?

ghci> random (mkStdGen 100) :: (Int, StdGen)

(–1352021624,651872571 1655838864)

Как и следовало ожидать! Тот же результат для тех же параметров. Так что давайте-ка передадим другой генератор в пара метре.

ghci> random (mkStdGen 949494) :: (Int, StdGen)

(539963926,466647808 1655838864)

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

ghci> random (mkStdGen 949488) :: (Float, StdGen)

(0.8938442,1597344447 1655838864)

ghci> random (mkStdGen 949488) :: (Bool, StdGen)

(False,1485632275 40692)

ghci> random (mkStdGen 949488) :: (Integer, StdGen)

(1691547873,1597344447 1655838864)

Подбрасывание монет

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

Будем представлять монету с помощью Bool. True – это «орёл», а False –«решка».

threeCoins :: StdGen –> (Bool, Bool, Bool)

threeCoins gen =

   let (firstCoin, newGen) = random gen

       (secondCoin, newGen') = random newGen

       (thirdCoin, newGen'') = random newGen'

   in  (firstCoin, secondCoin, thirdCoin)

Мы вызываем функцию random с генератором, который нам передали в параметре, и получаем монету и новый генератор. Затем снова вызываем функцию random, но на этот раз с новым генератором, чтобы получить вторую монету. Делаем то же самое с третьей монетой. Если бы мы вызывали функцию random с одним генератором, все монеты имели бы одинаковое значение, и в результате мы могли бы получать только (False, False, False) или (True, True, True).

ghci> threeCoins (mkStdGen 21)

(True,True,True)

ghci> threeCoins (mkStdGen 22)

(True,False,True)

ghci> threeCoins (mkStdGen 943)

(True,False,True)

ghci> threeCoins (mkStdGen 944)

(True,True,True)

Обратите внимание, что нам не надо писать random gen :: (Bool, StdGen): ведь мы уже указали, что мы желаем получить булевское значение, в декларации типа функции. По декларации язык Haskell может вычислить, что нам в данном случае нужно получить булевское значение.