Unknown - haskell-notes

называют полиморфным типом первого порядка (rank). Если forall стоит справа от стрелки, то его можно

вынести из выражения, например, следующие выражения эквивалентны:

fun ::forall a .

a ->(forall b .b ->b)

fun ::forall a b .a ->(b ->b)

Так мы можем привести не стандартный тип к стандартному. Если же forall встречается слева от стрел-

ки, как в функции runST, то его уже нельзя вынести. Это приводит к повышению порядка полиморфизма.

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

стрелки плюс один. Так в типе

runST ::(forall s . STs a) ->a

Слева от стрелки стоит тип первого порядка, прибавив единицу, получим порядок для всего выражения.

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

{-# Language Rank2Types #-}

{-# Language RankNTypes #-}

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

придётся помогать компилятору расставляя типы сложных функций вручную.

Лексически связанные типы

Мы уже привыкли к тому, что когда мы пишем

swap ::(a, b) ->(b, a)

компилятор понимает, что a и b указывают на один и тот же тип слева и справа от стрелки. При этом типы

a и b не обязательно разные. Иногда нам хочется расширить действие контекста функции и распространить

его на всё тело функции. Например ранее в этой главе, когда мы имитировали числа через типы, для того

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

instance Nata => Nat( Succa) where

toInt x =1 +toInt (proxy x)

proxy ::f a ->a

proxy =undefined

Единственное назначение функции proxy~– это передача информации о типе. Было бы гораздо удобнее

написать:

instance Nata => Nat( Succa) where

toInt x =1 +toInt (undefined ::a)

Проблема в том, что по умолчанию любой полиморфный тип в Haskell имеет первый ранг, компилятор

читает нашу запись как (x ::forall a .a), и получается, что мы говорим: x имеет любой тип, какой

захочешь! Не очень полезная информация. Компилятор заблудился и спрашивает у нас: “куда пойти?” А

мы ему: “да куда захочешь”. Как раз для таких случаев существует расширение ScopedTypeVariables. Оно

связывает тип, объявленный в заголовке класса/функции с типами, которые встречаются в теле функции.

В случае функций есть одно отличие от случая с классами. Если мы хотим расширить действие переменной

из объявления типа функции, необходимо упомянуть её в слове forall в стандартном положении (как для

типа первого порядка). У нас был ещё один пример с proxy:

Расширения | 263

dt ::( Natn, Fractionala) => Streamn a ->a

dt xs =1 /(fromIntegral $toInt $proxy xs)

whereproxy :: Streamn a ->n

proxy =undefined

В этом случае мы пишем:

{-# Language ScopedTypeVariables #-}

...

dt ::forall n .( Natn, Fractionala) => Streamn a ->a

dt xs =1 /(fromIntegral $toInt (undefined ::n))

Обратите внимение на появление forall в определении типа. Попробуйте скомпилировать пример без

него или переместите его в другое место. Во многих случаях применения этого рсширения можно избежать

с помощью стандартной функции asTypeOf, посмотрим на определение из Prelude:

asTypeOf ::a ->a ->a

asTypeOf x y =x

Фактически это функция const, оба типа которой одинаковы. Она часто используется в инфиксной форме

для фиксации типа первого аргумента:

q =f $x ‘asTypeOf‘ var

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

И другие удобства и украшения

Стоит упомянуть несколько расширений. Они лёгкие для понимания, в основном служат украшению

записи или для сокращения рутинного кода.

Директива derivingможет использоваться только с несколькими стандартными классами, но если мы

определили тип-обёртку через newtypeили просто синоним, то мы можем очень просто определить новый

тип экземпляром любого класса, который доступен завёрнутому типу. Как раз для этого существует расши-

рение GeneralizedNewtypeDeriving:

newtype MyDouble = MyDouble Double

deriving( Show, Eq, Enum, Ord, Num, Fractional, Floating)