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

Часто мы хотим сделать наши типы экземплярами определённых классов типов, но параметры типа просто не соответствуют тому,

 

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

newtype Pair b a = Pair { getPair:: (a, b) }

 

А теперь мы можем определить для него экземпляр класса

Functor так, чтобы функция отображала первый компонент:

instance Functor (Pair c) where

fmap f (Pair (x, y)) = Pair (f x, y)

Как видите, мы можем производить сопоставление типов, объ- явленных через декларацию newtype, с образцом. Мы производим сопоставление, чтобы получить лежащий в основе кортеж, при- меняем функцию f к первому компоненту в кортеже, а потом ис- пользуем конструктор значения Pair, чтобы преобразовать кортеж обратно в значение типа Pair b a. Если мы представим, какого типа была бы функция fmap, если бы она работала только с нашими но- выми парами, получится следующее:

fmap:: (a –> b) –> Pair c a –> Pair c b

Опять-таки, мы написали instance Functor (Pair c) where, и по- этому конструктор Pair c занял место идентификатора f в опреде- лении класса типов для Functor:

class Functor f where

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

Теперь, если мы преобразуем кортеж в тип Pair b a, можно бу- дет использовать с ним функцию fmap, и функция будет отображать первый компонент:

ghci> getPair $ fmap (*100) (Pair (2, 3)) (200,3)

ghci> getPair $ fmap reverse (Pair ("вызываю лондон", 3)) ("ноднол юавызыв",3)

 

О ленивости newtype

Единственное, что можно сделать с помощью ключевого слова newtype, – это превратить имеющийся тип в новый тип, поэтому внутренне язык Haskell может представлять значения типов, опре- делённых с помощью декларации newtype, точно так же, как и пер- воначальные, зная в то же время, что их типы теперь различаются. Это означает, что декларация newtype не только зачастую быстрее,

 

чем data, – её механизм сопоставления с образцом ленивее. Давай- те посмотрим, что это значит.

Как вы знаете, язык Haskell по умолчанию ленив, что означает, что какие-либо вычисления будут иметь место только тогда, ког- да мы пытаемся фактически напечатать результаты выполнения наших функций. Более того, будут произведены только те вычис- ления, которые необходимы, чтобы наша функция вернула нам результаты. Значение undefined в языке Haskell представляет со- бой ошибочное вычисление. Если мы попытаемся его вычислить (то есть заставить Haskell на самом деле произвести вычисление), напечатав его на экране, то в ответ последует настоящий припа- док гнева – в технической терминологии он называется исключе- нием:

ghci> undefined

*** Exception: Prelude.undefined

А вот если мы создадим список, содержащий в себе несколько значений undefined, но запросим только «голову» списка, которая не равна undefined, всё пройдёт гладко! Причина в том, что языку Haskell не нужно вычислять какие-либо из остальных элементов в списке, если мы хотим посмотреть только первый элемент. Вот пример:

ghci> head [3,4,5,undefined,2,undefined] 3

Теперь рассмотрите следующий тип:

data CoolBool = CoolBool { getCoolBool:: Bool }

Это ваш обыкновенный алгебраический тип данных, который был объявлен с использованием ключевого слова data. Он имеет один конструктор данных, который содержит одно поле с типом Bool. Давайте создадим функцию, которая сопоставляет с образцом значение CoolBool и возвращает значение "привет" вне зависимости от того, было ли значение Bool в CoolBool равно True или False:

helloMe:: CoolBool –> String helloMe (CoolBool _) = "привет"

Вместо того чтобы применять эту функцию к обычному значе- нию типа CoolBool, давайте сделаем ей обманный бросок – приме- ним её к значению undefined!

 

ghci> helloMe undefined

*** Exception: Prelude.undefined

Тьфу ты! Исключение! Почему оно возникло? Типы, определён- ные с помощью ключевого слова data, могут иметь много конструк- торов данных(хотя CoolBool имеет только один конструктор). Поэ- тому для того чтобы понять, согласуется ли значение, переданное нашей функции, с образцом (CoolBool _), язык Haskell должен вы- числить значение ровно настолько, чтобы понять, какой конструк- тор данных был использован, когда мы создавали значение. И когда мы пытаемся вычислить значение undefined, будь оно даже неболь- шим, возникает исключение.

Вместо ключевого слова data для CoolBool давайте попробуем использовать newtype:

newtype CoolBool = CoolBool { getCoolBool:: Bool }

Нам не нужно изменять нашу функцию helloMe, поскольку син- таксис сопоставления с образцом одинаков независимо от того, использовалось ли ключевое слово newtype или data для объявле- ния вашего типа. Давайте сделаем здесь то же самое и применим helloMe к значению undefined:

ghci> helloMe undefined "привет"

Сработало! Хм-м-м, почему? Ну, как вы уже узнали, когда вы исполь- зуете ключевое слово newtype, язык Haskell внутренне может представ- лять значения нового типа таким же образом, как и первоначальные значения. Ему не нужно помещать их ещё в одну коробку; он просто должен быть в курсе, что значения имеют разные типы. И поскольку язык Haskell знает, что типы, со- зданные с помощью ключевого сло- ва newtype, могут иметь лишь один конструктор данных и одно поле, ему не нужно вычислять значение,

 

переданное функции, чтобы убедиться, что значение соответству- ет образцу (CoolBool _).

Это различие в поведении может казаться незначительным, но на самом деле оно очень важно. Оно показывает, что хотя типы, оп- ределённые с помощью деклараций data и newtype, ведут себя оди- наково с точки зрения программиста (так как оба имеют конструк- торы данных и поля), это фактически два различных механизма. Тогда как ключевое слово data может использоваться для создания ваших новых типов с нуля, ключевое слово newtype предназначено для создания совершенно нового типа из существующего. Сравне- ние значений деклараций newtype с образцом не похоже на выни- мание содержимого коробки (что характерно для деклараций data); это скорее представляет собой прямое преобразование из одного типа в другой.