Миран Липовача - Изучай Haskell во имя добра!
max' :: (Ord a) => a –> a –> a
max' a b
| a <= b = b
| otherwise = a
Продолжим: напишем нашу собственную функцию сравнения, используя охранные выражения.
myCompare :: (Ord a) => a –> a –> Ordering
a `myCompare` b
| a == b = EQ
| a <= b = LT
| otherwise = GT
ghci> 3 `myCompare` 2
GT
ПРИМЕЧАНИЕ. Можно не только вызывать функции с помощью обратных апострофов, но и определять их так же. Иногда такую запись легче читать.
Где же ты, where?!
Программисты обычно стараются избегать многократного вычисления одних и тех же значений. Гораздо проще один раз вычислить что-то, а потом сохранить его значение. В императивных языках программирования эта проблема решается сохранением результата вычислений в переменной. В данном разделе вы научитесь использовать ключевое слово where для сохранения результатов промежуточных вычислений примерно с той же функциональностью.
В прошлом разделе мы определили вычислитель ИМТ и «ругалочку» на его основе таким образом:
bmiTell :: Double -> Double -> String
bmiTell weight height
| weight / height ^ 2 <= 18.5 = "Слышь, эмо, ты дистрофик!"
| weight / height ^ 2 <= 25.0 = "По части веса ты в норме.
Зато, небось, уродец!"
| weight / height ^ 2 <= 30.0 = "Ты толстый!
Сбрось хоть немного веса!"
| otherwise = "Мои поздравления, ты жирный боров!"
Заметили – мы повторили вычисление три раза? Операции копирования и вставки, да ещё повторенные трижды, – сущее наказание для программиста. Раз уж у нас вычисление повторяется три раза, было бы очень удобно, если бы мы могли вычислить его единожды, присвоить результату имя и использовать его, вместо того чтобы повторять вычисление. Можно переписать нашу функцию так:
bmiTell :: Double -> Double -> String bmiTell weight height
| bmi <= 18.5 = "Слышь, эмо, ты дистрофик!"
| bmi <= 25.0 = "По части веса ты в норме.
Зато, небось, уродец!"
| bmi <= 30.0 = "Ты толстый!
Сбрось хоть немного веса!"
| otherwise = "Мои поздравления, ты жирный боров!"
where bmi = weight / height ^ 2
Мы помещаем ключевое слово where после охранных выражений (обычно его печатают с тем же отступом, что и сами охранные выражения), а затем определяем несколько имён или функций. Эти имена видимы внутри объявления функции и позволяют нам не повторять код. Если вдруг нам вздумается вычислять ИМТ другим методом, мы должны исправить способ его вычисления только один раз.
Использование ключевого слова where улучшает читаемость, так как даёт имена понятиям и может сделать программы быстрее за счёт того, что переменные вроде bmi вычисляются лишь однажды. Попробуем зайти ещё дальше и представить нашу функцию так:
bmiTell :: Double -> Double -> String
bmiTell weight height
| bmi <= skinny = "Слышь, эмо, ты дистрофик!"
| bmi <= normal = "По части веса ты в норме.
Зато, небось, уродец!"
| bmi <= fat = "Ты толстый!
Сбрось хоть немного веса!"
| otherwise = "Мои поздравления, ты жирный боров!"
where bmi = weight / height ^ 2
skinny = 18.5
normal = 25.0
fat = 30.0
ПРИМЕЧАНИЕ. Заметьте, что все идентификаторы расположены в одном столбце. Если не отформатировать исходный код подобным образом, язык Haskell не поймёт, что все они – часть одного блока определений.
Область видимости декларации where
Переменные, которые мы определили в секции where нашей функции, видимы только ей самой, так что можно не беспокоиться о том, что мы засоряем пространство имён других функций. Если же нам нужны переменные, доступные в нескольких различных функциях, их следует определить глобально. Привязки в секции where не являются общими для различных образцов данной функции. Предположим, что мы хотим написать функцию, которая принимает на вход имя человека и, если это имя ей знакомо, вежливо его приветствует, а если нет – тоже приветствует, но несколько грубее. Первая попытка может выглядеть примерно так:
greet :: String -> String
greet "Хуан" = niceGreeting ++ " Хуан!"
greet "Фернандо" = niceGreeting ++ " Фернандо!"
greet name = badGreeting ++ " " ++ name
where niceGreeting = "Привет! Так приятно тебя увидеть,"
badGreeting = "О, чёрт, это ты,"
Однако эта функция работать не будет, так как имена, введённые в блоке where, видимы только в последнем варианте определения функции. Исправить положение может только глобальное определение функций niceGreeting и badGreeting, например:
badGreeting :: String
badGreeting = "О, чёрт, это ты,"
niceGreeting :: String
niceGreeting = "Привет! Так приятно тебя увидеть,"
greet :: String -> String
greet "Хуан" = niceGreeting ++ " Хуан!"
greet "Фернандо" = niceGreeting ++ " Фернандо!"
greet name = badGreeting ++ " " ++ name
Сопоставление с образцами в секции where
Можно использовать привязки в секции where и для сопоставления с образцом. Перепишем секцию where в нашей функции так:
...
where bmi = weight / height 2
(skinny, normal, fat) = (18.5, 25.0, 30.0)
Давайте создадим ещё одну простую функцию, которая принимает два аргумента: имя и фамилию, и возвращает инициалы.
initials :: String –> String –> String
initials firstname lastname = [f] ++ ". " ++ [l] ++ "."
where (f:_) = firstname
(l:_) = lastname
Можно было бы выполнять сопоставление с образцом прямо в параметрах функции (это проще и понятнее), но мы хотим показать, что это допускается сделать и в определениях после ключевого слова where.
Функции в блоке where
Точно так же, как мы определяли константы в секции where, можно определять и функции. Придерживаясь нашей темы «здорового» программирования, создадим функцию, которая принимает список из пар «вес–рост» и возвращает список из ИМТ.
calcBmis :: [(Double, Double)] –> [Double]
calcBmis xs = [bmi w h | (w, h) <– xs]
where bmi weight height = weight / height 2
Видите, что происходит? Причина, по которой нам пришлось представить bmi в виде функции в данном примере, заключается в том, что мы не можем просто вычислить один ИМТ для параметров, переданных в функцию. Нам необходимо пройтись по всему списку и для каждой пары вычислить ИМТ.
Пусть будет let
Определения, заданные с помощью ключевого слова let, очень похожи на определения в секциях where. Ключевое слово where – это синтаксическая конструкция, которая позволяет вам связывать выражения с переменными в конце функции; объявленные переменные видны во всём теле функции, включая сторожевые условия. Ключевое же слово let позволяет связывать выражения с именами в любом месте функции; конструкции let сами по себе являются выражениями, но их область видимости ограничена локальным контекстом. Таким образом, определение let, сделанное в охранном выражении, видно только в нём самом.
Как и любые другие конструкции языка Haskell, которые используются для привязывания имён к значениям, определения let могут быть использованы в сопоставлении с образцом. Посмотрим на них в действии! Вот как мы могли бы определить функцию, которая вычисляет площадь поверхности цилиндра по высоте и радиусу:
cylinder :: Double -> Double -> Double
cylinder r h =
let sideArea = 2 * pi * r * h
topArea = pi * r 2
in sideArea + 2 * topArea
Общее выражение выглядит так: let <определения> in <выражение>. Имена, которые вы определили в части let, видимы в выражении после ключевого слова in. Как видите, мы могли бы воспользоваться ключевым словом where для той же цели. Обратите внимание, что имена также выровнены по одной вертикальной позиции. Ну и какая разница между определениями в секциях where и let? Просто, похоже, в секции let сначала следуют определения, а затем выражение, а в секции where – наоборот.
На самом деле различие в том, что определения let сами по себе являются выражениями. Определения в секциях where – просто синтаксические конструкции. Если нечто является выражением, то у него есть значение. "Фуу!" – это выражение, и 3+5 – выражение, и даже head [1,2,3]. Это означает, что определение let можно использовать практически где угодно, например:
