Кортеж

В этой главе мы познакомимся с кортежем и ещё ближе подружимся с паттерн матчингом.

Кортеж (англ. tuple) — ещё одна стандартная структура данных, но, в отличие от списка, она может содержать данные как одного типа, так и разных.

Структуры, способные содержать данные разных типов, называют гетерогенными (в переводе с греческого: «разного рода»).

Вот как выглядит кортеж:

("Haskell", 2010)

Круглые скобки и значения, разделённые запятыми. Этот кортеж содержит значение типа String и ещё одно, типа Int. Вот ещё пример:

("Haskell", "2010", "Standard")

То есть ничто не мешает нам хранить в кортеже данные одного типа.

Тип кортежа

Тип списка строк, как вы помните, [String]. И не важно, сколько строк мы запихнули в список, одну или миллион — его тип останется неизменным. С кортежем же дело обстоит абсолютно иначе.

Тип кортежа зависит от количества его элементов. Вот тип кортежа, содержащего две строки:

(String, String)

Вот ещё пример:

(Double, Double, Int)

И ещё:

(Bool, Double, Int, String)

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

-- Разные типы
(String, String)
(String, String, String)

Действия над кортежами

Со списками можно делать много всего, а вот с кортежами — не очень. Самые частые действия — собственно формирование кортежа и извлечение хранящихся в нём данных. Например:

makeAlias :: String -> String -> (String, String)
makeAlias host alias = (host, alias)

Пожалуй, ничего проще придумать нельзя: на входе два аргумента, на выходе — двухэлементный кортеж с этими аргументами. Двухэлементный кортеж называют ещё парой (англ. pair). И хотя кортеж может содержать сколько угодно элементов, на практике именно пары встречаются чаще всего.

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

makeAlias host alias = (host, alias)

          ____          ____

               =====          =====

Мы просто указываем соответствие между левой и правой сторонами определения: «Пусть первый элемент пары будет равен аргументу host, а второй — аргументу alias». Ничего удобнее и проще и придумать нельзя. И если бы мы хотели получить кортеж из трёх элементов, это выглядело бы так:

makeAlias :: String -> String -> (String, String, String)
makeAlias host alias = (host, "https://" ++ host, alias)

          ____          ____                ____

               =====                              =====

Оператор ++ — это оператор конкатенации, склеивающий две строки в одну. Строго говоря, он склеивает два списка, но мы-то с вами уже знаем, что String есть ни что иное, как [Char]. Таким образом, "https://" ++ "www.google.com" даёт нам "https://www.google.com".

Извлечение элементов из кортежа также производится через паттерн матчинг:

main :: IO ()
main =
  let (host, alias) = makeAlias "173.194.71.106"
                                "www.google.com"
  in print (host ++ ", " ++ alias)

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

main :: IO ()
main =
  let pair  = makeAlias "173.194.71.106"
                        "www.google.com"
      host  = fst pair  -- Берём первое...
      alias = snd pair  -- Берём второе...
  in print (host ++ ", " ++ alias)

При запуске этой программы получим:

"173.194.71.106, www.google.com"

Стандартные функции fst и snd возвращают первый и второй элемент кортежа соответственно. Выражение pair соответствует паре, выражение host — значению хоста, а alias — значению имени. Но не кажется ли вам такой способ избыточным? Мы в Haskell любим изящные решения, поэтому предпочитаем паттерн матчинг. Вот как получается вышеприведённый способ:

let (host, alias) = makeAlias "173.194.71.106" "www.google.com"

let (host, alias) = ("173.194.71.106", "www.google.com")

                     данное значение
     это
     хост
                                       а вот это значение
           это
           имя

Вот такая простая магия. Функция makeAlias даёт нам пару, и мы достоверно знаем это! А если знаем, нам не нужно вводить промежуточные выражения вроде pair. Мы сразу говорим:

let (host, alias) = makeAlias "173.194.71.106" "www.google.com"

                    мы точно знаем, что выражение,
                    вычисленное этой функцией
     это вот
     такая пара

Это «зеркальная» модель: через паттерн матчинг формируем:

-- Формируем правую сторону
-- на основе левой...
host alias = (host, alias)

>>>>          >>>>

     >>>>>          >>>>>

и через него же извлекаем:

-- Формируем левую сторону
-- на основе правой...
(host, alias) = ("173.194.71.106", "www.google.com")

 <<<<            <<<<<<<<<<<<<<<<

       <<<<<                       <<<<<<<<<<<<<<<<

Вот ещё один пример работы с кортежем через паттерн матчинг:

chessMove :: String
          -> (String, String)
          -> (String, (String, String))
chessMove color (from, to) = (color, (from, to))

main :: IO ()
main = print (color ++ ": " ++ from ++ "-" ++ to)
  where
    (color, (from, to)) = chessMove "white" ("e2", "e4")

И на выходе получаем:

"white: e2-e4"

Обратите внимание, объявление функции отформатировано чуток иначе: типы выстроены друг под другом через выравнивание стрелок под двоеточием. Вы часто встретите такой стиль в Haskell-проектах.

Функция chessMove даёт нам кортеж с кортежем, а раз мы точно знаем вид этого кортежа, сразу указываем where-выражение в виде образца:

(color, (from, to)) = chessMove "white" ("e2", "e4")

 _____                          _______

         ====                            ====

               ..                              ....

Не всё

Мы можем вытаскивать по образцу лишь часть нужной нам информации. Помните универсальный образец _? Взгляните:

-- Поясняющие псевдонимы
type UUID     = String
type FullName = String
type Email    = String
type Age      = Int
type Patient = (UUID, FullName, Email, Age)

patientEmail :: Patient -> Email
patientEmail (_, _, email, _) = email

main :: IO ()
main =
  putStrLn (patientEmail ( "63ab89d"
                         , "John Smith"
                         , "[email protected]"
                         , 59
                         ))

Функция patientEmail даёт нам почту пациента. Тип Patient — это псевдоним для кортежа из четырёх элементов: уникальный идентификатор, полное имя, адрес почты и возраст. Дополнительные псевдонимы делают наш код яснее: одно дело видеть безликую String и совсем другое — Email.

Рассмотрим внутренность функции patientEmail:

patientEmail (_, _, email, _) = email

Функция говорит нам: «Да, я знаю, что мой аргумент — это четырёхэлементный кортеж, но меня в нём интересует исключительно третий по счёту элемент, соответствующий адресу почты, его я и верну». Универсальный образец _ делает наш код лаконичнее и понятнее, ведь он помогает нам игнорировать то, что нам неинтересно. Строго говоря, мы не обязаны использовать _, но с ним будет лучше.

А если ошиблись?

При использовании паттерн матчинга в отношении пары следует быть внимательным. Представим себе, что вышеупомянутый тип Patient был расширен:

type UUID      = String
type FullName  = String
type Email     = String
type Age       = Int
type DiseaseId = Int  -- Новый элемент.
type Patient = ( UUID
               , FullName
               , Email
               , Age
               , DiseaseId
               )

Был добавлен идентификатор заболевания. И всё бы хорошо, но внести изменения в функцию patientEmail мы забыли:

patientEmail :: Patient -> Email
patientEmail (_, _, email, _) = email

              ^  ^  ^      ^  -- А пятый где?

К счастью, в этом случае компилятор строго обратит наше внимание на ошибку:

Couldn't match type ‘(t0, t1, String, t2)’
               with ‘(UUID, FullName, Email, Age, DiseaseId)’
Expected type: Patient
  Actual type: (t0, t1, String, t2)
In the pattern: (_, _, email, _)

Оно и понятно: функция patientEmail использует образец, который уже некорректен. Вот почему при использовании паттерн матчинга следует быть внимательным.

На этом наше знакомство с кортежем считаю завершённым, в последующих главах мы будем использовать их периодически.

Для любопытных

Для работы с элементами многоэлементных кортежей можно использовать готовые библиотеки, во избежании длинных паттерн матчинговых цепочек. Например, пакет tuple:

Data.Tuple.Select

main :: IO ()
main = print (sel4 (123, 7, "hydra", "DC:4", 44, "12.04"))

Функция sel4 из модуля Data.Tuple.Select извлекает четвёртый по счёту элемент кортежа, в данном случае строку "DC:4". Там есть функции вплоть до sel32, авторы вполне разумно сочли, что никто, находясь в здравом уме и твёрдой памяти, не станет оперировать кортежами, состоящими из более чем 32 элементов.

Кроме того, мы и обновлять элементы кортежа можем:

import Data.Tuple.Update

main :: IO ()
main = print (upd2 2 ("si", 45))

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

("si",2)

Второй элемент кортежа изменился с 45 на 2.