Por que não posso tornar String uma instância de uma typeclass?

Dado :

data Foo =
  FooString String
  …

class Fooable a where --(is this a good way to name this?)
  toFoo :: a -> Foo

Eu quero fazer Stringuma instância de Fooable:

instance Fooable String where
  toFoo = FooString

GHC então reclama:

Illegal instance declaration for `Fooable String'
    (All instance types must be of the form (T t1 ... tn)
     where T is not a synonym.
     Use -XTypeSynonymInstances if you want to disable this.)
In the instance declaration for `Fooable String'

Se, em vez disso, eu usar [Char]:

instance Fooable [Char] where
  toFoo = FooString

GHC reclama:

Illegal instance declaration for `Fooable [Char]'
   (All instance types must be of the form (T a1 ... an)
    where a1 ... an are type *variables*,
    and each type variable appears at most once in the instance head.
    Use -XFlexibleInstances if you want to disable this.)
In the instance declaration for `Fooable [Char]'

Questão :

• Por que não posso fazer String e instância de uma typeclass?
• GHC parece disposto a me deixar escapar com isso se eu adicionar um sinalizador extra. isso é uma boa ideia?

Isso ocorre porque Stringé apenas um alias de tipo para [Char], que é apenas a aplicação do construtor de tipo []no tipo Char, então isso seria do formulário ([] Char). que não tem a forma (T a1 .. an)porque Charnão é uma variável de tipo.

O motivo dessa restrição é evitar a sobreposição de instâncias. Por exemplo, digamos que você tivesse um instance Fooable [Char]e, mais tarde, alguém apareceu e definiu um instance Fooable [a]. Agora, o compilador não será capaz de descobrir qual você deseja usar e apresentará um erro.

Ao usar -XFlexibleInstances, você basicamente promete ao compilador que não definirá nenhuma dessas instâncias.

Dependendo do que você está tentando realizar, pode ser melhor definir um wrapper:

newtype Wrapper = Wrapper String
instance Fooable Wrapper where
    ...

Você está enfrentando duas limitações de typeclasses Haskell98 clássicas:

• eles não permitem sinônimos de tipo em instâncias
• eles não permitem tipos aninhados que, por sua vez, não contêm variáveis ​​de tipo.

Essas restrições onerosas são eliminadas por duas extensões de linguagem:

• -XTypeSynonymInstances

que permite usar sinônimos de tipo (como Stringpara [Char]) e:

• -XFlexibleInstances

que levantam as restrições sobre os tipos de instância sendo da forma em T a b ..que os parâmetros são variáveis ​​de tipo. O -XFlexibleInstancessinalizador permite que o cabeçalho da declaração da instância mencione tipos aninhados arbitrários.

Observe que o levantamento dessas restrições às vezes pode levar à sobreposição de instâncias ; nesse ponto, uma extensão de linguagem adicional pode ser necessária para resolver a ambigüidade, permitindo que o GHC escolha uma instância para você.

Referências ::

• Regras relaxadas para o cabeçalho da instância , no Guia do usuário do GHC.

FlexibleInstances não é uma boa resposta na maioria dos casos. Melhores alternativas são envolver a String em um novo tipo ou introduzir uma classe auxiliar como esta:

class Element a where
   listToFoo :: [a] -> Foo

instance Element Char where
   listToFoo = FooString

instance Element a => Fooable [a] where
   toFoo = listToFoo

Veja também: http://www.haskell.org/haskellwiki/List_instance

Somando-se a essas respostas, se você não se sentir confortável em suspender as restrições, pode haver casos em que faria sentido envolver sua String em um novo tipo, que pode ser uma instância de uma classe. A compensação seria a feiura potencial, ter que embrulhar e desembrulhar em seu código.