Изучай Haskell во имя добра!

Липовача Миран

3

Синтаксис функций

 

 

Сопоставление с образцом

 

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

Когда вы определяете функцию, её определение можно разбить на несколько частей (клозов), по одной части для каждого образца. Это позволяет создать очень стройный код, простой и легко читаемый. Вы можете задавать образцы для любого типа данных – чисел, символов, списков, кортежей и т. д. Давайте создадим простую функцию, которая проверяет, является ли её параметр числом семь.

lucky :: Int -> String

lucky 7 = "СЧАСТЛИВОЕ ЧИСЛО 7!"

lucky x = "Прости, друг, повезёт в другой раз!"

Когда вы вызываете функцию lucky, производится проверка параметра на совпадение с заданными образцами в том порядке, в каком они были заданы. Когда проверка даст положительный результат, используется соответствующее тело функции. Единственный случай, когда число, переданное функции, удовлетворяет первому образцу, – когда оно равно семи. В противном случае проводится проверка на совпадение со следующим образцом. Следующий образец может быть успешно сопоставлен с любым числом; также он привязывает переданное число к переменной x.

Если в образце вместо реального значения (например, 7) пишут идентификатор, начинающийся со строчной буквы (например, x, y или myNumber), то этот образец будет сопоставлен любому переданному значению. Обратиться к сопоставленному значению в теле функции можно будет посредством введённого идентификатора.

Эта функция может быть реализована с использованием ключевого слова if. Ну а если нам потребуется написать функцию, которая называет цифры от 1 до 5 и выводит "Это число не в пределах от 1 до 5" для других чисел? Без сопоставления с образцом нам бы пришлось создать очень запутанное дерево условных выражений if – then – else. А вот что получится, если использовать сопоставление:

sayMe :: Int -> String

sayMe 1 = "Один!"

sayMe 2 = "Два!"

sayMe 3 = "Три!"

sayMe 4 = "Четыре!"

sayMe 5 = "Пять!"

sayMe x = "Это число не в пределах от 1 до 5"

Заметьте, что если бы мы переместили последнюю строку определения функции (образец в которой соответствует любому вводу) вверх, то функция всегда выводила бы "Это число не в пределах от 1 до 5", потому что невозможно было бы пройти дальше и провести проверку на совпадение с другими образцами.

Помните реализованную нами функцию факториала? Мы определили факториал числа n как произведение чисел [1..n]. Мы можем определить данную функцию рекурсивно, точно так же, как факториал определяется в математике. Начнём с того, что объявим факториал нуля равным единице.

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

factorial :: Integer -> Integer

factorial 0 = 1

factorial n = n * factorial (n – 1)

Мы в первый раз задали функцию рекурсивно. Рекурсия очень важна в языке Haskell, и подробнее она будет рассмотрена позже.

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

charName :: Char –> String

charName 'а' = "Артём"

charName 'б' = "Борис"

charName 'в' = "Виктор"

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

ghci> charName 'а'

"Артём"

ghci> charName 'в'

"Виктор"

ghci> charName 'м'

"*** Exception: Non-exhaustive patterns in function charName

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

 

Сопоставление с парами

Сопоставление с образцом может быть использовано и для кортежей. Что если мы хотим создать функцию, которая принимает два двумерных вектора (представленных в форме пары) и складывает их? Чтобы сложить два вектора, нужно сложить их соответствующие координаты. Вот как мы написали бы такую функцию, если б не знали о сопоставлении с образцом:

addVectors :: (Double, Double) -> (Double, Double) -> (Double, Double)

addVectors a b = (fst a + fst b, snd a + snd b)

Это, конечно, сработает, но есть способ лучше. Давайте исправим функцию, чтобы она использовала сопоставление с образцом:

addVectors :: (Double, Double) -> (Double, Double) -> (Double, Double)

addVectors (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)

Так гораздо лучше. Теперь ясно, что параметры функции являются кортежами; к тому же компонентам кортежа сразу даны имена – это повышает читабельность. Заметьте, что мы сразу написали образец, соответствующий любым значениям. Тип функции addVectors в обоих случаях совпадает, так что мы гарантированно получим на входе две пары:

ghci> :t addVectors

addVectors :: (Double, Double) -> (Double, Double) -> (Double, Double)

Функции fst и snd извлекают компоненты пары. Но как быть с тройками? Увы, стандартных функций для этой цели не существует, однако мы можем создать свои:

first :: (a, b, c) –> a

first (x, _, _) = x

second :: (a, b, c) –> b

second (_, y, _) = y

third :: (a, b, c) –> c

third (_, _, z) = z

Символ _ имеет то же значение, что и в генераторах списков. Он означает, что нам не интересно значение на этом месте, так что мы просто пишем _.

 

Сопоставление со списками и генераторы списков

В генераторах списков тоже можно использовать сопоставление с образцом, например:

ghci> let xs = [(1,3), (4,3), (2,4), (5,3), (5,6), (3,1)]

ghci> [a+b | (a,b) <– xs]

[4,7,6,8,11,4]

Если сопоставление с образцом закончится неудачей для одного элемента списка, просто произойдёт переход к следующему элементу.

Списки сами по себе (то есть заданные прямо в тексте образца списковые литералы) могут быть использованы при сопоставлении с образцом. Вы можете проводить сравнение с пустым списком или с любым образцом, который включает оператор : и пустой список. Так как выражение [1,2,3] – это просто упрощённая запись выражения 1:2:3:[], можно использовать [1,2,3] как образец.

Образец вида (x:xs) связывает «голову» списка с x, а оставшуюся часть – с xs, даже если в списке всего один элемент; в этом случае xs – пустой список.

ПРИМЕЧАНИЕ. Образец (x:xs) используется очень часто, особенно с рекурсивными функциями. Образцы, в определении которых присутствует : , могут быть использованы только для списков длиной не менее единицы.

Если вы, скажем, хотите связать первые три элемента с переменными, а оставшиеся элементы списка – с другой переменной, то можете использовать что-то наподобие (x:y:z:zs). Образец сработает только для списков, содержащих не менее трёх элементов.

Теперь, когда мы знаем, как использовать сопоставление с образцом для списков, давайте создадим собственную реализацию функции head:

head' :: [a] –> a

head' [] = error "Нельзя вызывать head на пустом списке, тупица!"

head' (x:_) = x

Проверим, работает ли это…

ghci> head' [4,5,6]

4

ghci> head' "Привет"

H'

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

Вызов функции error приводит к аварийному завершению программы, так что не стоит использовать её слишком часто. Но вызов функции head на пустом списке не имеет смысла.

Давайте напишем простую функцию, которая сообщает нам о нескольких первых элементах списка – в довольно неудобной, чересчур многословной форме.

tell :: (Show a) => [a] –> String

tell [] = "Список пуст"

tell (x:[]) = "В списке один элемент: " ++ show x

tell (x:y:[]) = "В списке два элемента: " ++ show x ++ " и " ++ show y

tell (x:y:_) = "Список длинный. Первые два элемента: " ++ show x

                ++ " и " ++ show y

Обратите внимание, что образцы (x:[]) и (x:y:[]) можно записать как [x] и [x,y]. Но мы не можем записать (x:y:_) с помощью квадратных скобок, потому что такая запись соответствует любому списку длиной два или более.

Вот несколько примеров использования этой функции:

ghci> tell [1]

"В списке один элемент: 1"

ghci> tell [True, False]

"В списке два элемента: True и False"

ghci> tell [1, 2, 3, 4]

"Список длинный. Первые два элемента: 1 и 2"

ghci> tell []

"Список пуст"

Функцию tell можно вызывать совершенно безопасно, потому что её параметр можно сопоставлять пустому списку, одноэлементному списку, списку с двумя и более элементами. Она умеет работать со списками любой длины и всегда знает, что нужно возвратить.

А что если определить функцию, которая умеет обрабатывать только списки с тремя элементами? Вот один такой пример:

badAdd :: (Num a) => [a] -> a

badAdd (x:y:z:[]) = x + y + z

А вот что случится, если подать ей не то, что она ждёт:

ghci> badAdd [100, 20]

*** Exception: Non-exhaustive patterns in function badAdd

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

И последнее замечание относительно сопоставления с образцами для списков: в образцах нельзя использовать операцию ++ (напомню, что это объединение двух списков). К примеру, если вы попытаетесь написать в образце (xs++ys), то Haskell не сможет определить, что должно попасть в xs, а что в ys. Хотя и могут показаться логичными сопоставления типа (xs++[x,y,z]) или даже (xs ++ [x]), работать это не будет – такова природа списков.

 

Именованные образцы

Ещё одна конструкция называется именованным образцом. Это удобный способ разбить что-либо в соответствии с образцом и связать результат разбиения с переменными, но в то же время сохранить ссылку на исходные данные. Такую задачу можно выполнить, поместив некий идентификатор образца и символ @ перед образцом, описывающим структуру данных. Например, так выглядит образец xs@(x:y:ys).

Подобный образец работает так же, как (x:y:ys), но вы легко можете получить исходный список по имени xs, вместо того чтобы раз за разом печатать x:y:ys в теле функции. Приведу пример:

firstLetter :: String –> String

firstLetter "" = "Упс, пустая строка!"

firstLetter all@(x:xs) = "Первая буква строки " ++ all ++ " это " ++ [x]

Загрузим эту функцию и посмотрим, как она работает:

ghci> firstLetter "Дракула"

"Первая буква строки Дракула это Д"

 

Эй, стража!

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

Вместо того чтобы объяснять их синтаксис, давайте просто напишем функцию с использованием охранных условий. Эта простая функция будет оценивать вас на основе ИМТ (индекса массы тела). Ваш ИМТ равен вашему весу, разделённому на квадрат вашего роста.

Если ваш ИМТ меньше 18,5, можно считать вас тощим. Если ИМТ составляет от 18,5 до 25, ваш вес в пределах нормы. От 25 до 30 – вы полненький; более 30 – тучный. Запишем эту функцию (мы не будем рассчитывать ИМТ, функция принимает его как параметр и ругнёт вас соответственно).

bmiTell :: Double -> String

bmiTell bmi

  | bmi <= 18.5 = "Слышь, эмо, ты дистрофик!"

  | bmi <= 25.0 = "По части веса ты в норме. Зато, небось, уродец!"

  | bmi <= 30.0 = "Ты толстый! Сбрось хоть немного веса!"

  | otherwise = "Мои поздравления, ты жирный боров!"

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

Если мы вызовем эту функцию с параметром 24.3, она вначале проверит, не является ли это значение меньшим или равным 18.5. Так как охранное выражение на данном значении равно False, функция перейдёт к следующему варианту. Проверяется следующее условие, и так как 24.3 меньше, чем 25.0, будет возвращена вторая строка.

Это очень напоминает большие деревья условий if – else в императивных языках программирования – только такой способ записи значительно лучше и легче для чтения. Несмотря на то что большие деревья условий if – else обычно не рекомендуется использовать, иногда задача представлена в настолько разрозненном виде, что просто невозможно обойтись без них. Охранные выражения – прекрасная альтернатива для таких задач.

Во многих случаях последним охранным выражением является otherwise («иначе»). Значение otherwise определяется просто: otherwise = True; такое условие всегда истинно. Работа условий очень похожа на то, как работают образцы, но образцы проверяют входные данные, а охранные выражения могут производить любые проверки.

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

Конечно же, мы можем использовать охранные выражения с функциями, которые имеют столько входных параметров, сколько нам нужно. Вместо того чтобы заставлять пользователя вычислять свой ИМТ перед вызовом функции, давайте модифицируем её так, чтобы она принимала рост и вес и вычисляла ИМТ:

bmiTell :: Double -> Double -> String

bmiTell weight height

  | weight / height ^ 2 <= 18.5 = "Слышь, эмо, ты дистрофик!"

  | weight / height ^ 2 <= 25.0 = "По части веса ты в норме.

                                   Зато, небось, уродец!"

  | weight / height ^ 2 <= 30.0 = "Ты толстый!

                                   Сбрось хоть немного веса!"

  | otherwise = "Мои поздравления, ты жирный боров!"

Ну-ка проверим, не толстый ли я…

ghci> bmiTell 85 1.90

"По части веса ты в норме. Зато, небось, уродец!"

Ура! По крайней мере, я не толстый! Правда, Haskell обозвал меня уродцем. Ну, это не в счёт.

ПРИМЕЧАНИЕ. Обратите внимание, что после имени функции и её параметров нет знака равенства до первого охранного выражения. Многие новички ставят этот знак, что приводит к ошибке.

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

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 можно использовать практически где угодно, например:

ghci> 4 * (let a = 9 in a + 1) + 2

42

Ключевое слово let подойдёт для определения локальных функций:

ghci> [let square x = x * x in (square 5, square 3, square 2)]

[(25,9,4)]

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

ghci> (let a = 10; b = 20 in a*b, let foo="Эй, "; bar = "там!" in foo ++ bar)

(200,"Эй, там!")

Как мы уже говорили ранее, определения в секции let могут использоваться при сопоставлении с образцом. Они очень полезны, к примеру, для того, чтобы быстро разобрать кортеж на элементы и привязать значения элементов к переменным, а также в других подобных случаях.

ghci> (let (a,b,c) = (1,2,3) in a+b+c) * 100

600

Если определения let настолько хороши, то почему бы только их всё время и не использовать? Ну, так как это всего лишь выражения, причём с локальной областью видимости, то их нельзя использовать в разных охранных выражениях. К тому же некоторые предпочитают, чтобы их переменные вычислялись после использования в теле функции, а не до того. Это позволяет сблизить тело функции с её именем и типом, что способствует большей читабельности.

 

Выражения let в генераторах списков

Давайте перепишем наш предыдущий пример, который обрабатывал списки пар вида (вес, рост), чтобы он использовал секцию let в выражении вместо того, чтобы определять вспомогательную функцию в секции where.

calcBmis :: [(Double, Double)] -> [Double]

calcBmis xs = [bmi | (w, h) <– xs, let bmi = w / h 2]

Мы поместили выражение let в генератор списка так, словно это предикат, но он не фильтрует список, а просто определяет имя. Имена, определённые в секции let внутри генератора списка, видны в функции вывода (часть до символа |) и для всех предикатов и секций, которые следуют после ключевого слова let. Так что мы можем написать функцию, которая выводит только толстяков:

calcBmis :: [(Double, Double)] -> [Double]

calcBmis xs = [bmi | (w, h) <– xs, let bmi = w / h ^ 2, bmi > 25.0]

Использовать имя bmi в части (w, h) <– xs нельзя, потому что она расположена до ключевого слова let.

 

Выражения let в GHCi

Часть in также может быть пропущена при определении функций и констант напрямую в GHCi. В этом случае имена будут видимы во время одного сеанса работы GHCi.

ghci> let zoot x y z = x * y + z

ghci> zoot 3 9 2

29

ghci> let boot x y z = x * y + z in boot 3 4 2

14

ghci> boot

:1:0: Not in scope: `boot'

Поскольку в первой строке мы опустили часть in, GHCi знает, что в этой строке zoot не используется, поэтому запомнит его до конца сеанса. Однако во втором выражении let часть in присутствует, и определённая в нём функция boot тут же вызывается. Выражение let, в котором сохранена часть in, является выражением и представляет некоторое значение, так что GHCi именно это значение и печатает.

 

Выражения для выбора из вариантов

Во многих императивных языках (C, C++, Java, и т. д.) имеется оператор case, и если вам доводилось программировать на них, вы знаете, что это такое. Вы берёте переменную и выполняете некую часть кода для каждого значения этой переменной – ну и, возможно, используете финальное условие, которое срабатывает, если не отработали другие.

Язык Haskell позаимствовал эту концепцию и усовершенствовал её. Само имя «выражения для выбора» указывает на то, что они являются… э-э-э… выражениями, так же как if – then – else и let. Мы не только можем вычислять выражения, основываясь на возможных значениях переменной, но и производить сопоставление с образцом.

Итак, берём переменную, выполняем сопоставление с образцом, выполняем участок кода в зависимости от полученного значения… где-то мы это уже слышали!.. Ах да, сопоставление с образцом по параметрам при объявлении функции! На самом деле это всего лишь навсего облегчённая запись для выражений выбора. Эти два фрагмента кода делают одно и то же – они взаимозаменяемы:

head' :: [a] –> a

head' [] = error "Никаких head для пустых списков!"

head' (x:_) = x

head' :: [a] –> a

head' xs =

  case xs of

   [] –> error "Никаких head для пустых списков!"

   (x:_) –> x

Как видите, синтаксис для выражений отбора довольно прост:

case expression of

  pattern –> result

  pattern –> result

  ...

Выражения проверяются на соответствие образцам. Сопоставление с образцом работает как обычно: используется первый образец, который подошёл. Если были опробованы все образцы и ни один не подошёл, генерируется ошибка времени выполнения.

Сопоставление с образцом по параметрам функции может быть сделано только при объявлении функции; выражения отбора могут использоваться практически везде. Например:

describeList :: [a] –> String

describeList xs = "Список " ++

  case xs of

   [] –> "пуст."

   [x] –> "одноэлементный."

   xs –> "длинный."

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

describeList :: [a] –> String

describeList xs = "Список " ++ what xs

  where

    what [] = "пуст."

    what [x] = "одноэлементный."

    what xs = "длинный."