Миран Липовача - Изучай Haskell во имя добра!
Кроме прочего, подобный подход позволяет избежать дублирования кода. Например, представьте себе, что какие-то «математики» решили, будто 2 – это на самом деле 3, и вам нужно изменить свою программу. Тогда вы могли бы просто переопределить doubleMe как x + x + x, и поскольку doubleUs вызывает doubleMe, данная функция автоматически работала бы в странном мире, где 2 – это 3.
Теперь давайте напишем функцию, умножающую число на два, но только при условии, что это число меньше либо равно 100 (поскольку все прочие числа и так слишком большие!):
doubleSmallNumber x = if x > 100
then x
else x*2
Мы только что воспользовались условной конструкцией if в языке Haskell. Возможно, вы уже знакомы с условными операторами из других языков. Разница между условной конструкцией if в Haskell и операторами if из императивных языков заключается в том, что ветвь else в языке Haskell является обязательной. В императивных языках вы можете просто пропустить пару шагов, если условие не выполняется, а в Haskell каждое выражение или функция должны что-то возвращать[4].
Можно было бы написать конструкцию if в одну строку, но я считаю, что это не так «читабельно». Ещё одна особенность условной конструкции в языке Haskell состоит в том, что она является выражением. Выражение – это код, возвращающий значение. 5 – это выражение, потому что возвращает 5; 4 + 8 – выражение, x + y – тоже выражение, потому что оно возвращает сумму x и y.
Поскольку ветвь else обязательна, конструкция if всегда что-нибудь вернёт, ибо является выражением. Если бы мы хотели добавить единицу к любому значению, получившемуся в результате выполнения нашей предыдущей функции, то могли бы написать её тело вот так:
doubleSmallNumber' x = (if x > 100 then x else x*2) + 1
Если опустить скобки, то единица будет добавляться только при условии, что x не больше 100. Обратите внимание на символ апострофа (') в конце имени функции. Он не имеет специального значения в языке Haskell. Это допустимый символ для использования в имени функции.
Обычно мы используем символ прямого апострофа ' для обозначения строгой (не ленивой) версии функции либо слегка модифицированной версии функции или переменной. Поскольку апостроф – допустимый символ в именах функций, мы можем определять такие функции:
conanO'Brien = "Это я, Конан О'Брайен!"
Здесь следует обратить внимание на две важные особенности. Во-первых, в названии функции мы не пишем имя conan с прописной буквы. Дело в том, что наименования функций не могут начинаться с прописной буквы – чуть позже мы разберёмся, почему. Во-вторых, данная функция не принимает никаких пара метров.
Когда функция не принимает аргументов, говорят, что это константная функция. Поскольку мы не можем изменить содержание имён (и функций) после того, как их определили, идентификатор conanO'Brien и строка "Это я, Конан О'Брайен!" могут использоваться взаимозаменяемо.
Списки
Как и списки покупок в реальном мире, списки в языке Haskell очень полезны. В данном разделе мы рассмотрим основы работы со списками, генераторами списков и строками (которые также являются списками).
Списки в языке Haskell являются гомогенными структурами данных; это означает, что в них можно хранить элементы только одного типа. Можно иметь список целых или список символов, но нельзя получить список с целыми числами и символами одновременно.
Списки заключаются в квадратные скобки, а элементы разделяются запятыми:
ghci> let lostNumbers = [4,8,15,16,23,42]
ghci> lostNumbers
[4,8,15,16,23,42]
ПРИМЕЧАНИЕ. Можно использовать ключевое слово let, чтобы определить имя прямо в GHCi. Например, выполнение let a = 1 из GHCi – эквивалент указания a = 1 в скрипте с последующей загрузкой.
Конкатенация
Объединение двух списков – стандартная задача. Она выполняется с помощью оператора ++[5].
ghci> [1,2,3,4] ++ [9,10,11,12] [1,2,3,4,9,10,11,12]
ghci> "привет" ++ " " ++ "мир"
"привет мир"
ghci> ['в','о'] ++ ['-'] ++ ['о','т']
"во-от"
ПРИМЕЧАНИЕ. Строки в языке Haskell являются просто списками символов. Например, строка привет – это то же самое, что и список ['п','р','и','в','е','т']. Благодаря этому для работы со строками можно использовать функции обработки символов, что очень удобно.
Будьте осторожны при использовании оператора ++ с длинными строками. Если вы объединяете два списка (даже если в конец первого из них дописывается второй, состоящий из одного элемента, например [1,2,3] ++ [4]), то язык Haskell должен обойти весь список с левой стороны от ++. Это не проблема, когда обрабатываются небольшие списки, но добавление к списку из 50 000 000 элементов займёт много времени. А вот если вы добавите что-нибудь в начало списка с помощью оператора : (также называемого «cons»), долго ждать не придётся.
ghci> 'В':"ОТ КОШКА"
"ВОТ КОШКА"
ghci> 5:[1,2,3,4,5]
[5,1,2,3,4,5]
Обратите внимание, что оператор : принимает число и список чисел или символ и список символов, в то время как ++ принимает два списка. Даже если вы добавляете один элемент в конец списка с помощью оператора ++, следует заключить этот элемент в квадратные скобки, чтобы он стал списком:
ghci> [1,2,3,4] ++ [5]
[1,2,3,4,5]
Написать [1,2,3,4] ++ 5 нельзя, потому что оба параметра оператора ++ должны быть списками, а 5 – это не список, а число.
Интересно, что [1,2,3] – это на самом деле синтаксический вариант 1:2:3:[]. Список [] – пустой, и если мы добавим к его началу 3, получится [3]; если затем добавим в начало 2, получится [2,3] и т. д.
ПРИМЕЧАНИЕ. Списки [], [[]] и [[],[],[]] совершенно разные. Первый – это пустой список; второй – список, содержащий пустой список; третий – список, содержащий три пустых списка.
Обращение к элементам списка
Если вы хотите извлечь элемент из списка по индексу, используйте оператор !!. Индексы начинаются с нуля.
ghci> "Стив Бушеми" !! 5
'Б'
ghci> [9.4,33.2,96.2,11.2,23.25] !! 1
33.2
Но если вы попытаетесь получить шестой элемент списка, состоящего из четырёх элементов, то получите сообщение об ошибке, так что будьте осторожны!
Списки списков
Списки могут содержать другие списки. Также они могут содержать списки, которые содержат списки, которые содержат списки…
ghci> let b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b ++ [[1,1,1,1]]
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3],[1,1,1,1]]
ghci> [6,6,6]:b
[[6,6,6],[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b !! 2
[1,2,2,3,4]
Вложенные списки могут быть разной длины, но не могут быть разных типов. Подобно тому как нельзя создать список, содержащий несколько символов и несколько чисел, нельзя создать и список, содержащий несколько списков символов и несколько списков чисел.
Сравнение списков
Списки можно сравнивать, только если они содержат сравнимые элементы. При использовании операторов <, <=, >= и > сравнение происходит в лексикографическом порядке. Сначала сравниваются «головы» списков; если они равны, то сравниваются вторые элементы. Если равны и вторые элементы, то сравниваются третьи – и т. д., пока не будут найдены различающиеся элементы. Результат сравнения списков определяется по результату сравнения первой пары различающихся элементов.
Сравним для примера [3,4,2]<[3,4,3]. Haskell видит, что 3 и 3 равны, поэтому переходит к сравнению 4 и 4, но так как они тоже равны, сравнивает 2 и 3. Число 2 меньше 3, поэтому первый список меньше второго. Аналогично выполняется сравнение на <=, >= и >:
ghci> [3,2,1] > [2,1,0]
True
ghci> [3,2,1] > [2,10,100]
True
ghci> [3,4,2] < [3,4,3]
True
ghci> [3,4,2] > [2,4]
True
ghci> [3,4,2] == [3,4,2]
True
Непустой список всегда считается больше, чем пустой. Это позволяет сравнивать друг с другом любые два списка, даже если один из них точно совпадает с началом другого.
Другие операции над списками
Что ещё можно делать со списками? Вот несколько основных функций работы с ними.
