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

В главе 11 мы обсудили пару способов, при помощи которых списковый тип может быть аппликативным функтором. Один из этих способов состоит в том, чтобы заставить оператор <*>брать каждую функцию из списка, являющегося его левым параметром, и применять её к каждому значению в списке, который находится справа, что в результате возвращает все возможные комбинации применения функции из левого списка к значению в правом:

ghci> [(+1),(*100),(*5)] <*> [1,2,3]

[2,3,4,100,200,300,5,10,15]

Второй способ заключается в том, чтобы взять первую функцию из списка слева от оператора <*>и применить её к первому значению справа, затем взять вторую функцию из списка слева и применить её ко второму значению справа, и т. д. В конечном счёте получается нечто вроде застёгивания двух списков.

Но списки уже имеют экземпляр класса Applicative, поэтому как нам определить для списков второй экземпляр класса Applicative? Как вы узнали, для этой цели был введён тип ZipList a. Он имеет один конструктор данных ZipList, у которого только одно поле. Мы помещаем оборачиваемый нами список в это поле. Далее для типа ZipListопределяется экземпляр класса Applicative, чтобы, когда нам понадобится использовать списки в качестве аппликативных функторов для застёгивания, мы могли просто обернуть их с по мощью конструктора ZipList. Как только мы закончили, разворачиваем их с помощью getZipList:

ghci> getZipList $ ZipList [(+1),(*100),(*5)] <*> ZipList [1,2,3]

[2,200,15]

Итак, какое отношение это имеет к ключевому слову newtype? Хорошо, подумайте, как бы мы могли написать объявление dataдля нашего типа ZipList a! Вот один из способов:

data ZipList a = ZipList [a]

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

data ZipList a = ZipList { getZipList :: [a] }

Это прекрасно смотрится и на самом деле работает очень хорошо. У нас было два способа сделать существующий тип экземпляром класса типов, поэтому мы использовали ключевое слово data, чтобы просто обернуть этот тип в другой, и сделали другой тип экземпляром вторым способом.

Ключевое слово newtypeв языке Haskell создано специально для тех случаев, когда мы хотим просто взять один тип и обернуть его во что-либо, чтобы представить его как другой тип. В существующих сейчас библиотеках тип ZipList aопределён вот так:

newtype ZipList a = ZipList { getZipList :: [a] }

Вместо ключевого слова dataиспользуется newtype. Теперь разберёмся, почему. Ну, к примеру, декларация newtypeбыстрее. Если вы используете ключевое слово dataдля оборачивания типа, появляются «накладные расходы» на все эти оборачивания и разворачивания, когда ваша программа выполняется. Но если вы воспользовались ключевым словом newtype, язык Haskell знает, что вы просто применяете его для оборачивания существующего типа в новый тип (отсюда название), поскольку хотите, чтобы внутренне он остался тем же, но имел иной тип. По этой причине язык Haskell может избавиться от оборачивания и разворачивания, как только решит, какое значение какого типа.

Так почему бы всегда не использовать newtypeвместо data? Когда вы создаёте новый тип из имеющегося типа, используя ключевое слово newtype, у вас может быть только один конструктор значения, который имеет только одно поле. Но с помощью ключевого слова dataвы можете создавать типы данных, которые имеют несколько конструкторов значения, и каждый конструктор может иметь ноль или более полей:

data Profession = Fighter | Archer | Accountant

data Race = Human | Elf | Orc | Goblin

data PlayerCharacter = PlayerCharacter Race Profession

При использовании ключевого слова newtypeмы можем использовать ключевое слово deriving– точно так же, как мы бы делали это с декларацией data. Мы можем автоматически порождать экземпляры для классов Eq, Ord, Enum, Bounded, Showи Read. Если мы породим экземпляр для класса типа, то оборачиваемый нами тип уже должен иметь экземпляр для данного класса типов. Это логично, поскольку ключевое слово newtypeвсего лишь оборачивает существующий тип. Поэтому теперь мы сможем печатать и сравнивать значения нашего нового типа, если сделаем следующее:

newtype CharList = CharList { getCharList :: [Char] } deriving (Eq, Show)

Давайте попробуем:

ghci> CharList "Вот что мы покажем!"

CharList {getCharList = "Вот что мы покажем!"}

ghci> CharList "бенни" == CharList "бенни"

True

ghci> CharList "бенни" == CharList "устрицы"

False

В данном конкретном случае использования ключевого слова newtypeконструктор данных имеет следующий тип:

CharList :: [Char] –> CharList

Он берёт значение типа [Char]и возвращает значение типа CharList. Из предыдущих примеров, где мы использовали конструктор данных CharList, видно, что действительно так оно и есть. И наоборот, функция getCharList, которая была автоматически сгенерирована за нас (потому как мы использовали синтаксис записей с именованными полями в нашей декларации newtype), имеет следующий тип:

getCharList :: CharList –> [Char]

Она берёт значение типа CharListи преобразует его в значение типа [Char]. Вы можете воспринимать это как оборачивание и разворачивание, но также можете рассматривать это как преобразование значений из одного типа в другой.

Часто мы хотим сделать наши типы экземплярами определённых классов типов, но параметры типа просто не соответствуют тому, что нам требуется. Сделать для типа Maybeэкземпляр класса Functorлегко, потому что класс типов Functorопределён вот так:

class Functor f where

fmap :: (a -> b) -> f a -> f b

Поэтому мы просто начинаем с этого:

instance Functor Maybe where

А потом реализуем функцию fmap.

Все параметры типа согласуются, потому что тип Maybeзанимает место идентификатора fв определении класса типов Functor. Если взглянуть на функцию fmap, как если бы она работала только с типом Maybe, в итоге она ведёт себя вот так:

fmap :: (a -> b) -> Maybe a -> Maybe b

Разве это не замечательно? Ну а что если мы бы захотели определить экземпляр класса Functorдля кортежей так, чтобы при отображении кортежа с помощью функции fmapвходная функция применялась к первому элементу кортежа? Таким образом, выполнение fmap (+3) (1,1)вернуло бы (4,1). Оказывается, что написание экземпляра для этого отчасти затруднительно. При использовании типа Maybeмы просто могли бы написать: instance Functor Maybe where, так как только для конструкторов типа, принимающих ровно один параметр, могут быть определены экземпляры класса Functor. Но, похоже, нет способа сделать что-либо подобное при использовании типа (a,b)так, чтобы в итоге изменялся только параметр типа a, когда мы используем функцию fmap. Чтобы обойти эту проблему, мы можем сделать новый тип из нашего кортежа с помощью ключевого слова newtypeтак, чтобы второй параметр типа представлял тип первого компонента в кортеже: