Есть ли список расширений GHC, которые считаются «безопасными»?

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

В результате я часто получаю что-то подобное в верхней части моих файлов .hs:

{-# LANGUAGE TypeFamilies
           , MultiParamTypeClasses
           , FunctionalDependencies
           , FlexibleContexts
           , FlexibleInstances
           , UndecidableInstances
           , OverlappingInstances #-}

Я не возражаю против этого, но часто я чувствую, что я делаю слепые жертвы, чтобы успокоить Великого Бога GHC. Он жалуется, что определенный фрагмент кода недопустим без языкового расширения X, поэтому я добавляю прагму для X. Затем он требует, чтобы я включил Y, поэтому я добавляю прагму для Y. К тому времени, когда это завершится, я включить три или четыре языковых расширения, которые я действительно не понимаю, и я понятия не имею, какие из них являются «безопасными».

Чтобы объяснить, что я имею в виду под «безопасным»:

I understand that UndecidableInstances is safe, because although it may cause the compiler to not terminate, as long as the code compiles it won't have unexpected side effects.

On the other hand, OverlappingInstances is clearly unsafe, because it makes it very easy for me to accidentally write code that gives runtime errors.

Итак, мой вопрос:

Is there a list of GHCextensions which are considered 'safe' and which are 'unsafe'?

Ответы на вопрос(1)

Решение Вопроса

Вероятно, лучше посмотреть, чтоSafeHaskell позволяет:

Safe Language

The Safe Language (enabled through -XSafe) restricts things in two different ways:

Certain GHC LANGUAGE extensions are disallowed completely. Certain GHC LANGUAGE extensions are restricted in functionality.

Below is precisely what flags and extensions fall into each category:

Disallowed completely: GeneralizedNewtypeDeriving, TemplateHaskell Restricted functionality: OverlappingInstances, ForeignFunctionInterface, RULES, Data.Typeable See Restricted Features below Doesn't Matter: all remaining flags.

Restricted and Disabled GHC Haskell Features

In the Safe language dialect we restrict the following Haskell language features:

ForeignFunctionInterface: This is mostly safe, but foreign import declarations that import a function with a non-IO type are be disallowed. All FFI imports must reside in the IO Monad. RULES: As they can change the behaviour of trusted code in unanticipated ways, violating semantic consistency they are restricted in function. Specifically any RULES defined in a module M compiled with -XSafe are dropped. RULES defined in trustworthy modules that M imports are still valid and will fire as usual. OverlappingInstances: This extension can be used to violate semantic consistency, because malicious code could redefine a type instance (by containing a more specific instance definition) in a way that changes the behaviour of code importing the untrusted module. The extension is not disabled for a module M compiled with -XSafe but restricted. While M can define overlapping instance declarations, they can only be used in M. If in a module N that imports M, at a call site that uses a type-class function there is a choice of which instance to use (i.e overlapping) and the most specific choice is from M (or any other Safe compiled module), then compilation will fail. It is irrelevant if module N is considered Safe, or Trustworthy or neither. Data.Typeable: We allow instances of Data.Typeable to be derived but we don't allow hand crafted instances. Derived instances are machine generated by GHC and should be perfectly safe but hand crafted ones can lie about their type and allow unsafe coercions between types. This is in the spirit of the original design of SYB.

In the Safe language dialect we disable completely the following Haskell language features:

GeneralizedNewtypeDeriving: It can be used to violate constructor access control, by allowing untrusted code to manipulate protected data types in ways the data type author did not intend. I.e can be used to break invariants of data structures. TemplateHaskell: Is particularly dangerous, as it can cause side effects even at compilation time and can be used to access abstract data types. It is very easy to break module boundaries with TH.

Я помню, прочитав, что взаимодействиеFunctionalDependencies а такжеUndecidableInstances также может быть небезопасным, потому что помимо разрешения неограниченной глубины стека контекстаUndecidableInstances также поднимает так называемыйусловие покрытия (раздел 7.6.3.2), но я не могу найти ссылку на это в данный момент.

РЕДАКТИРОВАТЬ 2015-10-27: с тех пор, как GHC получил поддержку типовых ролей,GeneralizedNewtypeDeriving больше не небезопасно (Я не уверен, что еще могло измениться.)

 15 июн. 2012 г., 00:53
Это правда, что, вероятно, с GNTD это проще, чем со многими другими, но можно избежать небезопасных действий с любым из расширений, которые позволили бы вам делать небезопасные вещи. В этот момент вопрос становится немного бессмысленным.
 20 июн. 2012 г., 18:37
Я полагаю, что я понял, что первоначальный вопрос - это «вещи, которые вы не должны включать», если не знаете, что делаете »; Я думаю, что TH, RULES и FFI легко ошибиться, и назад, когда существовал Impredicative Polymorphism, это был очень большой случай "если GHC предлагает это, и вы не знаете, что это такое, вы, вероятно, делаете что-то неправильный & Quot ;.
 20 июн. 2012 г., 17:34
Если значение вопроса «почти никогда не является хорошей идеей» а не "делает этоpossible делать плохие вещи », тогда я думаю, что единственные расширения, которые действительно соответствуют этим требованиям, - это Overlapping и IncoherentInstances. Я имею в виду, точно так же, как GNTD, поэтому TH, RULES, FFI и т. Д. Также могут использоваться совершенно безопасным и законным способом.
 19 июн. 2012 г., 11:39
Я не согласен. Тот факт, что GNTD небезопасен, на самом деле является ошибкой, и довольно сомнительной. Кроме того, я думаю, что концепция «безопасной» в вопросе отличается нетривиальными способами от того, что подразумевается в вопросе.
 14 июн. 2012 г., 13:47
Я не уверен, что это совершенно справедливо.GeneralizedNewtypeDeriving Он прост в использовании безопасным способом, и большинство его применений, я готов поспорить, явно безопасны. Вы должны создать и создать несколько довольно коварных классов, чтобы это было небезопасно.

Ваш ответ на вопрос