6.20. Прагмы

6.20.1. LANGUAGE прагма

{-# LANGUAGE ⟨ext⟩, ⟨ext⟩, ... #-}

Где:

заголовок файла

Включить или отключить набор расширений языка.

Прагма LANGUAGE позволяет включить расширения языка портативным способом. Предполагается, что все компиляторы Haskell поддерживают прагму LANGUAGE с одинаковым синтаксисом, хотя, конечно, не все расширения поддерживаются всеми компиляторами. Прагму LANGUAGE следует использовать вместо OPTIONS_GHC, если это возможно.

Например, для включения FFI и предварительной обработки с CPP:

{-# LANGUAGE ForeignFunctionInterface, CPP #-}

LANGUAGE — это прагма заголовка файла (см. Прагмы).

Каждое расширение языка также может быть преобразовано в командную строку, добавив префикс «-X»; например, -XForeignFunctionInterface. (Аналогично, все флаги «-X» можно записать как прагмы LANGUAGE).

Список всех поддерживаемых расширений языка можно получить, вызвав ghc --supported-extensions (см. --supported-extensions).

Любое расширение типа Extension , определённое в Language.Haskell.Extension, может быть использовано. GHC сообщит об ошибке, если любое из запрошенных расширений не поддерживается.

6.20.2. OPTIONS_GHC прагма

{-# OPTIONS_GHC ⟨flags⟩ #-}

Где:

заголовок файла

Прагма OPTIONS_GHC используется для указания дополнительных параметров, которые передаются компилятору при компиляции данного исходного файла. Подробнее см. Параметры командной строки в исходных файлах.

Предыдущие версии GHC принимали OPTIONS вместо OPTIONS_GHC, но это теперь устаревшая форма.

OPTIONS_GHC — это прагма заголовка файла (см. Прагмы).

6.20.3. INCLUDE прагма

Прагма INCLUDE раньше была необходима для указания заголовочных файлов, которые должны быть включены при использовании FFI и компиляции через C. Она больше не требуется для GHC, но принимается (и игнорируется) для совместимости с другими компиляторами.

6.20.4. WARNING и DEPRECATED прагмы

{-# WARNING #-}

Где:

имя объявления или модуля

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

{-# DEPRECATED #-}

Где:

имя объявления или модуля

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

Существует три способа использования этих прагм.

• Можно работать с целым модулем:

  module Wibble {-# DEPRECATED "Use Wobble instead" #-} where
    ...
  

  Или:

  module Wibble {-# WARNING "This is an unstable interface." #-} where
    ...
  

  При компиляции любого модуля, импортирующего Wibble, GHC выведет указанное сообщение.

• Можно прикрепить предупреждение к функции, классу, типу или конструктору данных с помощью следующих объявлений верхнего уровня:

  {-# DEPRECATED f, C, T "Don't use these" #-}
  {-# WARNING unsafePerformIO "This is unsafe; I hope you know what you're doing" #-}
  

  При компиляции любого модуля, импортирующего и использующего указанные сущности, GHC выведет указанное сообщение.

  Вы можете прикрепить предупреждение только к сущностям, объявленным на верхнем уровне в компилируемом модуле, и вы можете использовать только неквалифицированные имена в списке сущностей. Заглавное имя, например, T относится либо к конструктору типа T либо к конструктору данных T, или к обоим, если оба находятся в области видимости. Если оба находятся в области видимости, в настоящее время нет способа указать один без другого (ср. фиксы Инфиксные конструкторы типов, классы и переменные типов).

• Можно добавить предупреждение к экземпляру (включая производные экземпляры):

  instance {-# DEPRECATED "Don't use" #-} Show T1 where { .. }
  instance {-# WARNING "Don't use either" #-} Show G1 where { .. }
  
  deriving instance {-# DEPRECATED "to be removed" #-} Eq T2
  deriving instance {-# WARNING "to be removed as well" #-} Eq G2
  

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

  foo = show (MkT1 :: T1) -- warning: uses "instance Show T1"
  
  bar :: forall a. Eq a => a -> Bool
  bar x = x == x
  baz :: T2 -> Bool
  baz = bar -- warning: uses "instance Eq T2"
  quux :: Eq T2 => T2 -> Bool
  quux = bar -- no warning: does not use "instance Eq T2"
  

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

• Наконец, можно добавить предупреждение к полю экспорта, будь то обычный экспорт:

  module Wibble (
      {-# DEPRECATED "Do not use this type" #-} T,
      {-# WARNING "This is a hacky function" #-} f
    ) where
    ...
  

  Или повторный экспорт импорта из другого модуля:

  module Wibble (
      {-# DEPRECATED "Import this function from A instead" #-} g
    ) where
  import A
  

  Или повторный экспорт целого модуля:

  module Wibble (
      {-# DEPRECATED "This declaration has been moved to B instead" #-}
        module B
    ) where
  import B
  

  При компиляции любого модуля, импортирующего и использующего указанные сущности, GHC выведет указанное сообщение.

  Сущность будет предупреждена только в том случае, если все её экспортные элементы устарели:

  module Wibble (
      {-# WARNING "This would not be warned about" #-} g,
      module A
    )
  import A (g)
  

  Если включён флаг :ghc-flag: -Wincomplete-export-warnings , такие случаи предупреждаются.

  Кроме того, все объявления предупреждений одного имени должны быть предупреждены с той же прагмой и сообщением:

  module Wibble (
      {-# WARNING "This would throw an error" #-} T(T1),
      {-# WARNING "Because the warning messages differ for T" #-} T,
  )
  ...
  

Также обратите внимание, что аргумент к DEPRECATED и WARNING также может быть списком строк, в этом случае строки будут отображаться на отдельных строках в результирующем сообщении о предупреждении,

{-# DEPRECATED foo, bar ["Don't use these", "Use gar instead"] #-}

Предупреждения и устаревания не сообщаются для (a) использования в определяющем модуле, (b) определения метода в экземпляре класса, (c) неквалифицированного использования сущности, импортированной через различные модули, когда не все они предупреждены, и (d) использования в списке экспорта (за исключением предупреждений экспорта). Последнее уменьшает ложные жалобы в библиотеке, в которой один модуль собирает и повторно экспортирует экспорт нескольких других.

Прагма WARNING (но не прагма DEPRECATED ) может необязательно указать категорию предупреждения как строковую литерал после ключевого слова in . Это влияет на флаг, используемый для подавления предупреждения. Примеры выше не указывают категорию, поэтому применяется категория по умолчанию deprecations , и они могут быть подавлены с помощью флага -Wno-deprecations (и его синонима -Wno-warnings-deprecations).

Если категория указана, предупреждение можно подавить с помощью флага -Wno-x-⟨category⟩, например, предупреждения из следующей прагмы можно подавить с помощью -Wno-x-partial:

{-# WARNING in "x-partial" head "This function is partial..." #-}

В качестве альтернативы, предупреждения из всех прагм WARNING и DEPRECATED независимо от категории можно подавить с помощью -Wno-extended-warnings.

Когда устаревшее имя появляется как в пространстве имён значений, так и в пространстве имён типов (т.е. происходит омонимия) прагмы WARNING и DEPRECATED повлияют на оба:

{-# LANGUAGE PatternSynonyms #-}

data D = MkD
pattern D = MkD
{-# DEPRECATED D "This will deprecate both the type D and the pattern synonym D" #-}

Можно указать пространство имён имени, о котором нужно предупредить или которое устарело, с помощью спецификаторов type и data , но для этого необходимо включить ExplicitNamespaces:

{-# LANGUAGE PatternSynonyms #-}

data D = MkD
pattern D = MkD
{-# DEPRECATED data D "This will deprecate only the pattern synonym D" #-}
{-# DEPRECATED type D "This will deprecate only the type D" #-}

6.20.5. MINIMAL pragma

{-# MINIMAL ⟨name⟩ | ⟨name⟩ , ... #-}

Где:

в теле класса

Определяет методы, необходимые для минимально полного экземпляра класса.

Pragma MINIMAL используется для указания минимального полного определения класса, т.е. для указания, какие методы должны быть реализованы всеми экземплярами. Если экземпляр не удовлетворяет минимальному полному определению, то генерируется предупреждение. Это может быть полезно, когда у класса есть методы с циклическими значениями по умолчанию. Например

class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
    x == y = not (x /= y)
    x /= y = not (x == y)
    {-# MINIMAL (==) | (/=) #-}

Без pragma MINIMAL предупреждение не генерировалось бы для экземпляра, который не реализует ни один из методов.

Синтаксис для минимального полного определения:

mindef ::= name
        |  '(' mindef ')'
        |  mindef '|' mindef
        |  mindef ',' mindef

Вертикальная черта обозначает дизъюнкцию, т.е. один из двух вариантов обязателен. Запятая обозначает конъюнкцию, т.е. оба варианта обязательны. Конъюнкция имеет более высокий приоритет, чем дизъюнкция.

Если в объявлении класса нет pragma MINIMAL , то это то же самое, что и pragma {-# MINIMAL op1, op2, ..., opn #-} , где opi — это методы, которым не хватает метода по умолчанию в объявлении класса (см. -Wmissing-methods, Предупреждения и проверка на соответствие).

Это предупреждение можно отключить с помощью флага -Wno-missing-methods.

6.20.6. INLINE и NOINLINE директивы

Эти директивы управляют встраиванием определений функций.

key_function :: Int -> String -> (Bool, Double)
{-# INLINE key_function #-}

{-# INLINE thenUs #-}
{-# INLINE returnUs #-}

class C a where
    op1 :: a -> a

    op2 :: [a] -> [a]
    op2 xs = reverse (xs ++ xs)
    {-# INLINE op2 #-}

instance C T1 where
    op1 x = ...blah...

instance C T2 where
    {-# INLINE op1 #-}
    op1 x = ...blah...
    op2 xs = ...blah...

6.20.7. OPAQUE директива

{-# OPAQUE ⟨name⟩ #-}

Где:

на верхнем уровне

Указывает компилятору гарантировать, что каждый вызов name остаётся вызовом name, а не какой-то переименованной версией.

Директива OPAQUE — это ещё более сильная разновидность директивы NOINLINE. Как и NOINLINE, именованные функции, помеченные директивой OPAQUE, не встраиваются и не будут специализироваться. В отличие от NOINLINE, именованные функции, помеченные директивой OPAQUE, остаются неизменными после преобразования Worker/Wrapper. В отличие от NOINLINE, OPAQUE не имеет управления фазой.

Фактически, каждый вызов именованной функции, помеченной директивой OPAQUE, остаётся вызовом этой именованной функции, а не какой-то переименованной версии. Вам никогда не нужно использовать директиву OPAQUE, если у вас нет причин заботиться о переименовании.

6.20.8. LINE директива

{-# LINE ⟨lineno⟩ "⟨file⟩" #-}

Где:

везде

Генерируется препроцессорами для передачи номеров строк исходного кода.

Эта директива похожа на C-директиву #line, и используется в основном в автоматически сгенерированном коде Haskell. Она позволяет указывать номер строки и имя файла исходного кода; например

{-# LINE 42 "Foo.vhs" #-}

если вы сгенерировали текущий файл из чего-то под названием Foo.vhs, а эта строка соответствует строке 42 в оригинале. GHC скорректирует свои сообщения об ошибках так, чтобы они ссылались на строку/файл, указанные в директиве LINE.

Директивы LINE , сгенерированные из Template Haskell, устанавливают позицию файла и строки на время вставки и ограничены областью вставки. Обратите внимание, что поскольку Template Haskell абстрагирует синтаксическое дерево, позиции файлов не увеличиваются автоматически.

6.20.9. COLUMN директива

Это аналог директивы LINE, и предназначена для использования в автоматически сгенерированном коде Haskell. Она позволяет указать номер столбца исходного кода; например

foo = do
  {-# COLUMN 42 #-}pure ()
  pure ()

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

6.20.10. RULES директива

Директива RULES позволяет указывать правила переписывания. Она описана в Правила переписывания.

6.20.11. SPECIALIZE pragma

{-# SPECIALIZE ⟨name⟩ :: ⟨type⟩ #-}

Запросить, чтобы GHC специализировал полиморфное значение на определённый тип.

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

hammeredLookup :: Ord key => [(key, value)] -> key -> value

Если она часто используется со списками с Widget ключами, вы можете специализировать её следующим образом:

{-# SPECIALIZE hammeredLookup :: [(Widget, value)] -> Widget -> value #-}

• Pragma SPECIALIZE для функции может быть помещено в любом месте, где могла бы стоять её сигнатура типа. Более того, вы также можете SPECIALIZE импортированную функцию, при условии, что ей была задана pragma INLINABLE в месте её определения (Pragma INLINABLE).
• Pragma SPECIALIZE имеет эффект генерации (а) специализированной версии функции и (б) правила переписывания (см. Правила переписывания), которое переписывает вызов неспециализированной функции в вызов специализированной. Кроме того, если для функции f задана pragma SPECIALIZE, GHC автоматически создаст специализации для всех функций, перегруженных с помощью класса типов, вызываемых f, если они находятся в том же модуле, что и pragma SPECIALIZE, или если они INLINABLE; и так далее, транзитивно.

• Вы можете добавить управление фазами (Управление фазами) к правилу RULE, сгенерированному pragma SPECIALIZE, так же, как если бы вы написали pragma RULE непосредственно. Например:

  {-# SPECIALIZE [0] hammeredLookup :: [(Widget, value)] -> Widget -> value #-}
  

  генерирует правило специализации, которое срабатывает только в Фазе 0 (конечной фазе). Если вы не укажете управление фазами в pragma SPECIALIZE, управление фазами наследуется из pragmy inline (если есть) функции. Например:

  foo :: Num a => a -> a
  foo = ...blah...
  {-# NOINLINE [0] foo #-}
  {-# SPECIALIZE foo :: Int -> Int #-}
  

  Pragma NOINLINE сообщает GHC не выполнять встраивание foo до Фазы 0; и это свойство наследуется правилом RULE специализации, которое, следовательно, будет срабатывать только в Фазе 0.

  Основная причина использования управления фазами при специализации заключается в том, что вы можете написать оптимизационные правила, которые срабатывают на ранних этапах процесса компиляции, и только затем специализировать вызовы функции. Если специализация выполняется слишком рано, оптимизационные правила могут не сработать.

• Тип в pragma SPECIALIZE может быть любым типом, который менее полиморфен, чем тип исходной функции. В конкретных терминах, если исходная функция — f, то pragma

  {-# SPECIALIZE f :: <type> #-}
  

  является допустимой тогда и только тогда, когда определение

  f_spec :: <type>
  f_spec = f
  

  является допустимым. Вот несколько примеров (мы приводим только сигнатуру типа исходной функции, а не её код):

  f :: Eq a => a -> b -> b
  {-# SPECIALISE f :: Int -> b -> b #-}
  
  g :: (Eq a, Ix b) => a -> b -> b
  {-# SPECIALISE g :: (Eq a) => a -> Int -> Int #-}
  
  h :: Eq a => a -> a -> a
  {-# SPECIALISE h :: (Eq a) => [a] -> [a] -> [a] #-}
  

  В последнем примере будет сгенерировано правило RULE с несколько сложной левой частью (попробуйте сами), поэтому оно может не сработать должным образом. Если вы используете этот тип специализации, сообщите нам, насколько хорошо он работает.

-- A GADT for arrays with type-indexed representation
data Arr e where
  ArrInt :: !Int -> ByteArray# -> Arr Int
  ArrPair :: !Int -> Arr e1 -> Arr e2 -> Arr (e1, e2)

(!:) :: Arr e -> Int -> e
{-# SPECIALISE INLINE (!:) :: Arr Int -> Int -> Int #-}
{-# SPECIALISE INLINE (!:) :: Arr (a, b) -> Int -> (a, b) #-}
(ArrInt _ ba)     !: (I# i) = I# (indexIntArray# ba i)
(ArrPair _ a1 a2) !: i      = (a1 !: i, a2 !: i)

module Map( lookup, blah blah ) where
  lookup :: Ord key => [(key,a)] -> key -> Maybe a
  lookup = ...
  {-# INLINABLE lookup #-}

module Client where
  import Map( lookup )

  data T = T1 | T2 deriving( Eq, Ord )
  {-# SPECIALISE lookup :: [(T,a)] -> T -> Maybe a

module Client where
  import Map( lookup )

  data T = T1 | T2 deriving( Eq, Ord )

  findT1 :: [(T,a)] -> Maybe a
  findT1 m = lookup m T1   -- A call of lookup at type T

6.20.12. SPECIALIZE instance pragma

{-# SPECIALIZE instance ⟨instance head⟩ #-}

Where:

тело экземпляра

Такая же идея, только для объявлений экземпляров. Например:

instance (Eq a) => Eq (Foo a) where {
   {-# SPECIALIZE instance Eq (Foo [(Int, Bar)]) #-}
   ... usual stuff ...
 }

Pragma должна располагаться внутри части where объявления экземпляра.

6.20.13. UNPACK директива

{-# UNPACK #-}

Где:

поле конструктора данных

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

Директива UNPACK указывает компилятору распаковать содержимое поля конструктора в сам конструктор, удалив уровень косвенности. Например:

data T = T {-# UNPACK #-} !Float
           {-# UNPACK #-} !Float

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

Распаковка полей конструкторов должна использоваться только в сочетании с -O [1], чтобы предоставить компилятору возможность раскрытия, чтобы повторная упаковка могла быть удалена как можно чаще. Например:

f :: T -> Float
f (T f1 f2) = f1 + f2

Компилятор избежит повторной упаковки f1 и f2, встраивая + для чисел с плавающей запятой, но только когда -O включен.

Любые данные с единственным конструктором подходят для распаковки; например

data T = T {-# UNPACK #-} !(Int,Int)

будет хранить две Int непосредственно в конструкторе T, уплощая пару. Также поддерживается многоуровневая распаковка:

data T = T {-# UNPACK #-} !S
data S = S {-# UNPACK #-} !Int {-# UNPACK #-} !Int

будет хранить два необработанных Int# непосредственно в конструкторе T. Распаковщик также может видеть newtypes.

С версии 9.6.1 также можно распаковывать типы данных с несколькими конструкторами, фактически преобразуя поле в необработанную сумму распаковок каждого конструктора (см. UnboxedSums).

Также см. флаг -funbox-strict-fields, который в основном эквивалентен добавлению {-# UNPACK #-} к каждому строгому полю конструктора, являющемуся типом данных с одним конструктором. Однако типы сумм не будут распаковываться автоматически, только с явной директивой.

6.20.14. NOUNPACK директива

{-# NOUNPACK #-}

Где:

на верхнем уровне

Указывает компилятору не распаковывать поле конструктора.

Директива NOUNPACK указывает компилятору не распаковывать содержимое поля конструктора. Пример:

data T = T {-# NOUNPACK #-} !(Int,Int)

Даже с флагами -funbox-strict-fields и -O, поле конструктора T не распаковывается.

6.20.15. SOURCE директива

{-# SOURCE #-}

Где:

после оператора import

Импортировать модуль по hs-boot файлу, чтобы разорвать цикл модуля.

Директива {-# SOURCE #-} используется только в объявлениях import, чтобы разорвать цикл модуля. Более подробная информация приведена в Взаимно рекурсивные модули и файлы hs-boot.

6.20.16. COMPLETE директивы

{-# COMPLETE #-}

Где:

на верхнем уровне

Укажите набор конструкторов или псевдонимов шаблонов, которые составляют полное соответствие.

Директива COMPLETE используется для информирования проверяющего соответствие шаблонов о том, что определенный набор шаблонов является полным, и что любая функция, соответствующая всем указанным шаблонам, является полной.

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

Например, типы данных 2 * A и A + A изоморфны, но некоторые вычисления выражаются более естественно с помощью одного или другого. Чтобы получить лучшее из обоих вариантов, мы можем выбрать один в качестве реализации, а затем предоставить набор псевдонимов шаблонов, чтобы пользователи могли использовать другое представление, если они этого пожелают. Затем мы можем указать директиву COMPLETE, чтобы проинформировать проверяющего соответствие шаблонов о том, что функция, соответствующая как LeftChoice, так и RightChoice, является полной.

data Choice a = Choice Bool a

pattern LeftChoice :: a -> Choice a
pattern LeftChoice a = Choice False a

pattern RightChoice :: a -> Choice a
pattern RightChoice a = Choice True a

{-# COMPLETE LeftChoice, RightChoice #-}

foo :: Choice Int -> Int
foo (LeftChoice n) = n * 2
foo (RightChoice n) = n - 2

Директивы COMPLETE используются только проверяющим соответствие шаблонов. Если определение функции соответствует всем конструкторам, указанным в директиве, компилятор не выведет предупреждение.

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

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

Это особенно полезно в случаях, когда указанные конструкторы являются полиморфными, например:

data Proxy a = Proxy

class IsEmpty a where
  isEmpty :: a -> Bool

class IsCons a where
  type Elt a
  isCons :: a -> Maybe (Elt a, a)

pattern Empty :: IsEmpty a => a
pattern Empty <- (isEmpty -> True)

pattern Cons :: IsCons a => Elt a -> a -> a
pattern Cons x xs <- (isCons -> Just (x,xs))

instance IsEmpty (Proxy a) where
  isEmpty Proxy = True

instance IsEmpty [a] where
  isEmpty = null

instance IsCons [a] where
  type Elt [a] = a
  isCons [] = Nothing
  isCons (x:xs) = Just (x,xs)

{-# COMPLETE Empty :: Proxy #-}
{-# COMPLETE Empty, Cons :: [] #-}

foo :: Proxy a -> Int
foo Empty = 0

bar :: [a] -> Int
bar Empty = 0
bar (Cons _ _) = 1

baz :: [a] -> Int
baz Empty = 0

В этом примере foo и bar не получат предупреждения, поскольку их сопоставления шаблонов покрыты двумя директивами COMPLETE выше, но baz получит предупреждение о неполноте.

6.20.17. OVERLAPPING, OVERLAPPABLE, OVERLAPS, и INCOHERENT директивы

{-# OVERLAPPING #-}

{-# OVERLAPPABLE #-}

{-# OVERLAPS #-}

{-# INCOHERENT #-}

Где:

в заголовке экземпляра

Директивы OVERLAPPING, OVERLAPPABLE, OVERLAPS, INCOHERENT используются для указания поведения перекрытия для отдельных экземпляров, как описано в разделе Перекрывающиеся экземпляры. Директивы пишутся сразу после ключевого слова instance, как показано здесь:

instance {-# OVERLAPPING #-} C t where ...