6.7.4. Синонимы шаблонов

6.7.4.1. Синонимы шаблонов-записей

Также можно определять синонимы шаблонов, которые ведут себя так же, как конструкторы записей. Синтаксис для этого выглядит так:

pattern Point :: Int -> Int -> (Int, Int)
pattern Point{x, y} = (x, y)

Идея состоит в том, что затем можно использовать Point так, как если бы мы определили новый тип данных MyPoint с двумя полями x и y.

data MyPoint = Point { x :: Int, y :: Int }

Обычный синоним шаблона можно использовать двумя способами, а Point — семью. Именно теми же способами, что и обычный конструктор записи.

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

Синтаксис и семантика синонимов шаблонов подробно рассматриваются в следующих подразделах. Дополнительные сведения приведены в статье.

Дополнительные сведения см. на странице Wiki.

6.7.4.2. Синтаксис и область видимости синонимов шаблонов

Объявление синонима шаблона может быть однонаправленным, двунаправленным или явно двунаправленным. Синтаксис однонаправленных синонимов шаблонов:

pattern pat_lhs <- pat

синтаксис двунаправленных синонимов шаблонов:

pattern pat_lhs = pat

и синтаксис явно двунаправленных синонимов шаблонов:

pattern pat_lhs <- pat where
  pat_lhs = expr                      -- lhs restricted, see below

Изменяя форму pat_lhs, можно определять синонимы шаблонов с префиксной, инфиксной или записной формой. Их синтаксис представлен ниже:

В pat_lhs для явно двунаправленного создания нельзя использовать синтаксис записи. (Поскольку expr в правой части может создавать другие конструкторы данных.) Можно использовать охранные условия и несколько уравнений.

Объявления синонимов шаблонов могут находиться только на верхнем уровне модуля. В частности, они не допускаются в качестве локальных определений.

Переменные в левой части определения связываются шаблоном в правой части. Для двунаправленных синонимов шаблонов все переменные правой части должны также встречаться в левой части; кроме того, шаблоны с подстановочными знаками и шаблоны-представления не допускаются. Для однонаправленных и явно двунаправленных синонимов шаблонов ограничений на шаблон в правой части нет.

Синонимы шаблонов нельзя определять рекурсивно.

Можно указывать прагмы COMPLETE, чтобы сообщить проверке полноты сопоставления с образцом, что набор синонимов шаблонов является полным.

6.7.4.3. Импорт и экспорт синонимов шаблонов

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

Чтобы экспортировать их отдельно, в спецификации экспорта или импорта необходимо предварить имена шаблонов ключевым словом data или pattern, например:

module Example (data Zero) where
  -- alternatively: pattern Zero

data MyNum = MkNum Int

pattern Zero :: MyNum
pattern Zero = MkNum 0

Без указания пространства имён data имя Zero в списке экспорта будет интерпретировано как конструктор типа.

Использование ключевого слова data в списках импорта и экспорта требует расширения ExplicitNamespaces и GHC ≥9.14. Этот вариант предпочтительнее pattern, если только не требуется поддерживать более старые версии GHC.

В спецификации импорта или экспорта также можно использовать ключевое слово data (или pattern), чтобы импортировать или экспортировать обычный конструктор данных. Например:

import Data.Maybe( data Just )

поместит в область видимости конструктор данных Just типа Maybe, не помещая туда конструктор типа Maybe.

Начиная с GHC 8.0.1, синонимы шаблонов также можно «объединять» с экспортируемым конструктором типа, чтобы такой шаблон считался конструктором данных этого типа. Чтобы объединить синоним шаблона, нужно указать его в списке экспорта модуля, экспортирующего конструктор типа. Например, чтобы объединить Zero с MyNum, можно написать следующее:

module Example ( MyNum(Zero) ) where

Если затем модуль импортирует MyNum из Example, он также импортирует синоним шаблона Zero.

В списке экспорта также можно использовать специальный токен .., означающий все текущие объединённые конструкторы. Например, можно написать:

module Example ( MyNum(.., Zero) ) where

в этом случае Example экспортирует конструктор типа MyNum вместе с конструктором данных MkNum и синонимом шаблона Zero.

Типы объединённых синонимов шаблонов проверяются, чтобы убедиться, что они совпадают с типом конструктора, с которым их объединяют. Синоним шаблона P нельзя объединить с конструктором типа T, если тип P явно несовместим с T.

Модуль, который импортирует MyNum(..) из Example, а затем повторно экспортирует MyNum(..), также экспортирует все синонимы шаблонов, объединённые с MyNum в Example. Более полное описание можно найти в Wiki.

6.7.4.4. Типизация синонимов шаблонов

Пусть задано определение синонима шаблона вида

pattern P var1 var2 ... varN <- pat

ему назначается тип шаблона вида

pattern P :: CReq => CProv => t1 -> t2 -> ... -> tN -> t

где ⟨CReq⟩ и ⟨CProv⟩ — контексты типов, а ⟨t1⟩, ⟨t2⟩, …, ⟨tN⟩ и ⟨t⟩ — типы. Обратите внимание на необычную форму типа с двумя контекстами ⟨CReq⟩ и ⟨CProv⟩:

• ⟨CReq⟩ — ограничения, необходимые для сопоставления с шаблоном.
• ⟨CProv⟩ — ограничения, предоставляемые при успешном сопоставлении с шаблоном.

Например, рассмотрим

data T a where
  MkT :: (Show b) => a -> b -> T a

f1 :: (Num a, Eq a) => T a -> String
f1 (MkT 42 x) = show x

pattern ExNumPat :: (Num a, Eq a) => (Show b) => b -> T a
pattern ExNumPat x = MkT 42 x

f2 :: (Eq a, Num a) => T a -> String
f2 (ExNumPat x) = show x

Здесь f1 не использует синонимы шаблонов. Для сопоставления с числовым шаблоном 42 вызывающий код должен удовлетворять ограничениям (Num a, Eq a), поэтому они появляются в типе f1. Вызов show порождает ограничение (Show b), где b — экзистенциальная переменная типа, связанная сопоставлением с образцом MkT. Однако это же сопоставление с образцом также предоставляет ограничение (Show b) (см. тип MkT), поэтому всё работает.

Точно такие же рассуждения применимы к ExNumPat: сопоставление с ExNumPat требует ограничений (Num a, Eq a) и предоставляет ограничение (Show b).

Обратите также внимание на следующие моменты:

• В обычном случае, когда CProv пуст, (то есть ()), его можно вообще опустить в приведённой выше сигнатуре типа шаблона для P.

• Однако если CProv не пуст, а CReq — пуст, приведённую выше сигнатуру типа шаблона для P необходимо указать в виде

  P :: () => CProv => t1 -> t2 -> .. -> tN -> t
  

• Команда GHCi :info показывает типы шаблонов в этом формате.

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

  -- Inferred type would be 'a -> [a]'
  pattern SinglePair :: (a, a) -> [(a, a)]
  pattern SinglePair x = [x]
  

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

  pattern Left', Right' :: a -> Either a a
  pattern Left' x  = Left x
  pattern Right' x = Right x
  

• Правила лексически ограниченных переменных типа (см. раздел Лексически ограниченные переменные типа) применяются к сигнатурам синонимов шаблонов. Согласно этим правилам, над определением синонима шаблона распространяется область видимости только переменных типа из явного, синтаксически видимого внешнего forall (универсальных переменных); экзистенциальные переменные, связанные внутренним forall, в неё не входят. Например:

  data T a where
     MkT :: Bool -> b -> (b->Int) -> a -> T a
  
  pattern P :: forall a. forall b. b -> (b->Int) -> a -> T a
  pattern P x y v <- MkT True x y (v::a)
  

  Здесь универсальная переменная типа a распространяет область видимости на определение P, а экзистенциальная переменная b — нет. (См. обсуждение в задаче #14998.)

• Для двунаправленного синонима шаблона его использование в качестве выражения имеет тип

  (CReq, CProv) => t1 -> t2 -> ... -> tN -> t
  

  Поэтому в предыдущем примере ExNumPat при использовании в выражении имеет тип

  ExNumPat :: (Num a, Eq a, Show b) => b -> T t
  

  Обратите внимание: это немного более ограничительно, чем выражение MkT 42 x, которому не потребовалось бы (Eq a).

• Рассмотрим эти два синонима шаблонов:

  data S a where
     S1 :: Bool -> S Bool
  
  pattern P1 :: Bool -> Maybe Bool
  pattern P1 b = Just b
  
  pattern P2 :: () => (b ~ Bool) => Bool -> S b
  pattern P2 b = S1 b
  
  f :: Maybe a -> String
  f (P1 x) = "no no no"     -- Type-incorrect
  
  g :: S a -> String
  g (P2 b) = "yes yes yes"  -- Fine
  

  Шаблон P1 может сопоставляться только со значением типа Maybe Bool, поэтому функция f отклоняется, поскольку сигнатура типа имеет вид Maybe a. (Чтобы убедиться в этом, представьте, что синоним шаблона раскрывается.)

  С другой стороны, функция g работает, поскольку сопоставление с P2 (обёрткой над GADT S) предоставляет локальное равенство (a~Bool). Если указать явную сигнатуру шаблона P2 :: Bool -> S Bool, тип P2 станет менее полиморфным и будет вести себя точно так же, как P1, поэтому g будет отклонена.

  Иными словами, если для синонимов шаблонов требуется поведение, аналогичное GADT, то, в отличие от конкретных конструкторов данных, например S1, тип необходимо записывать с явно указанными предоставляемыми равенствами. Для конкретного конструктора данных, например S1, сигнатуру типа можно записать как S1 :: Bool -> S Bool или S1 :: (b~Bool) => Bool -> S b — эти формы эквивалентны. Для синонимов шаблонов это не так: формы различаются, чтобы различать два описанных выше случая. (Обсуждение этого решения см. в задаче #9953.)

6.7.4.5. Сопоставление с синонимами шаблонов

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

Точнее, семантика сопоставления с образцом описана в разделе 3.17 отчёта Haskell 2010. К неформальной семантике из раздела 3.17.2 добавляется следующее правило:

• Если шаблон является шаблоном-конструктором (P p1 ... pn), где P — синоним шаблона, определённый с помощью P x1 ... xn = p или P x1 ... xn <- p, то:

  1. Сопоставить значение v с p. Если это сопоставление завершается неудачей или расходится, то и всё сопоставление (с синонимом шаблона) завершается неудачей или расходится. В противном случае сопоставление с p должно связать переменные x1 ... xn; пусть они будут связаны со значениями v1 ... vn.
  2. Сопоставить v1 с p1, v2 с p2 и так далее. Если какое-либо из этих сопоставлений завершается неудачей или расходится, то и всё сопоставление завершается неудачей или расходится.
  3. Если все сопоставления с pi успешны, сопоставление успешно и связывает переменные, связанные pi. (xi не связываются; они остаются локальными для объявления синонима шаблона.)

Например, в следующей программе f и f' эквивалентны:

pattern Pair x y <- [x, y]

f (Pair True True) = True
f _                = False

f' [x, y] | True <- x, True <- y = True
f' _                              = False

Обратите внимание, что строгость f отличается от строгости g, определённого ниже:

g [True, True] = True
g _            = False

*Main> f (False:undefined)
*** Exception: Prelude.undefined
*Main> g (False:undefined)
False

6.7.4.6. Прагмы для синонимов шаблонов

Начиная с GHC 9.2, для синонимов шаблонов поддерживаются прагмы INLINABLE, INLINE и NOINLINE. Например:

pattern InlinablePattern x = [x]
{-# INLINABLE InlinablePattern #-}
pattern InlinedPattern x = [x]
{-# INLINE InlinedPattern #-}
pattern NonInlinedPattern x = [x]
{-# NOINLINE NonInlinedPattern #-}

Как и для других прагм INLINABLE, INLINE и NOINLINE, можно указать фазу, к которой применяется прагма:

pattern Q x = [x]
{-# NOINLINE[1] Q #-}

Прагмы применяются как при использовании шаблона в качестве сопоставителя, так и при его использовании в качестве конструктора данных. Для явно двунаправленных синонимов шаблонов прагму нужно указывать на верхнем уровне, а не внутри предложения where. Например, следующий код не скомпилируется:

pattern HeadC x <- x:xs where
  HeadC x = [x]
  {-# INLINE HeadC #-}

а этот скомпилируется:

pattern HeadC x <- x:xs where
  HeadC x = [x]
{-# INLINE HeadC #-}

Если для шаблона не указана прагма, решение о встраивании принимается на основе собственных эвристик GHC.