Cómo escribo, "si typeclass a, entonces a también es una instancia de b según esta definición".

Question

Tengo una clase de tipo MyClass, y hay una función en ella que produce un String. Quiero utilizar esto para dar a entender una instancia de Show, de modo que pueda pasar los tipos que implementan MyClass a . Hasta ahora tengo,

class MyClass a where 
    someFunc :: a -> a 
    myShow :: a -> String 

instance MyClass a => Show a where 
    show a = myShow a 

que da el error Constraint is no smaller than the instance head. También probé,

class MyClass a where 
    someFunc :: a -> a 
    myShow :: a -> String 

instance Show (MyClass a) where 
    show a = myShow a 

que da el error, utilizan Class MiClase como type`.

¿Cómo puedo expresar correctamente esta relación en Haskell? Gracias.

Debo añadir que deseo hacer un seguimiento de esto con instancias específicas de MyClass que emiten cadenas específicas según su tipo. Por ejemplo,

data Foo = Foo 
data Bar = Bar 

instance MyClass Foo where 
    myShow a = "foo" 

instance MyClass Bar where 
    myShow a = "bar" 

main = do 
    print Foo 
    print Bar 

Answer 1

(Edit: abandonar el cuerpo para la posteridad, pero saltar al final de la solución real)

En la declaración instance MyClass a => Show a, vamos a examinar el error "Restricción no es menor que la cabeza instancia." La restricción es la restricción de clase de tipo a la izquierda de '=>', en este caso MyClass a. El "encabezado de instancia" es todo después de la clase para la que está escribiendo una instancia, en este caso a (a la derecha de Show). Una de las reglas de inferencia de tipo en GHC requiere que la restricción tenga menos constructores y variables que el encabezado. Esto es parte de lo que se llama 'Paterson Conditions'. Estos existen como una garantía de que la verificación de tipos termina.

En este caso, la restricción es exactamente la misma que la del encabezado, es decir, a, por lo que no pasa esta prueba. Puede eliminar las verificaciones de condición de Paterson habilitando UndecidableInstances, muy probablemente con el pragma {-# LANGUAGE UndecidableInstances #-}.

En este caso, esencialmente está utilizando su clase MyClass como sinónimo de clase de clase para la clase Show. Crear sinónimos de clase como este es uno de los usos canónicos de la extensión UndecidableInstances, por lo que puede usarlo de forma segura aquí.

'Indecidible' significa que GHC no puede probar que la verificación de tipo terminará. Aunque parezca peligroso, lo peor que puede pasar al habilitar las UndecidableInstances es que el compilador realizará un bucle, que finalmente terminará después de agotar la pila. Si se compila, entonces obviamente la verificación de tipo terminó, por lo que no hay problemas. La extensión peligrosa es IncoherentInstances, que es tan mala como suena.

Editar: otro problema hecho posible por este enfoque surge de esta situación:

instance MyClass a => Show a where 

data MyFoo = MyFoo ... deriving (Show) 

instance MyClass MyFoo where 

Ahora bien, hay dos instancias de mostrar para MyFoo, el de la cláusula de derivar y el uno para MyClass casos. El compilador no puede decidir cuál usar, por lo que rescatará con un mensaje de error. Si intenta realizar instancias MyClass de tipos que no controla que ya tienen instancias Show, deberá usar newtypes para ocultar las instancias Show existentes. Incluso los tipos sin MyClass casos se sigue el conflicto, porque la definición instance MyClass => Show a porque la definición de hecho proporciona una implementación para todos los posibles a (el cheque contexto viene en adelante; no es involucrado con la selección ejemplo)

Así que ese es el mensaje de error y cómo UndecidableInstances lo hace desaparecer Desafortunadamente, es un gran problema usarlo en el código real, por razones que Edward Kmett explica. El ímpetu original fue evitar especificar una restricción Show cuando ya existe una restricción MyClass. Dado que, lo que haría es simplemente usar myShow desde MyClass en lugar de show. No necesitará la restricción Show en absoluto.

Answer 2

Se puede compilar, pero no con Haskell 98, tiene que habilitar algunas extensiones de lenguaje:

{-# LANGUAGE FlexibleInstances #-} 
{-# LANGUAGE UndecidableInstances #-} 
-- at the top of your file 

casos flexibles está ahí para permitir contexto en el declaración de la instancia. Realmente no sé el significado de IndecidiblesInstancias, pero evitaría todo lo que pueda.

Answer 3

creo que sería mejor hacerlo al revés:

class Show a => MyClass a where 
    someFunc :: a -> a 

myShow :: MyClass a => a -> String 
myShow = show 

Answer 4

deseo de estar en desacuerdo con fuerza con las soluciones rotos planteaba hasta ahora.

instance MyClass a => Show a where 
    show a = myShow a 

Debido a la forma en que funciona la resolución de la instancia, esta es una instancia muy peligrosa para correr!

La resolución de la instancia se realiza por coincidencia de patrones efectiva en el lado derecho de cada instancia de =>, sin tener en cuenta lo que está a la izquierda del =>.

Cuando ninguna de esas instancias se superpone, esto es algo hermoso. Sin embargo, lo que está diciendo aquí es "Aquí hay una regla que debe usar para CADA Mostrar instancia. Cuando se le pida una instancia de show para cualquier tipo, necesitará una instancia de MyClass, así que consiga eso, y aquí está la implementación." - una vez que el compilador se ha comprometido a elegir usar su instancia, (solo en virtud del hecho de que 'a' se unifica con todo) ¡no tiene ninguna posibilidad de retroceder y usar cualquier otra instancia!

Si activa {-# LANGUAGE OverlappingInstances, IncoherentInstances #-}, etc. para compilarlo, obtendrá fallas no tan sutiles cuando vaya a escribir módulos que importen el módulo que proporciona esta definición y que necesitan utilizar cualquier otra instancia de Show. En última instancia, podrás obtener este código para compilar con suficientes extensiones, ¡pero lamentablemente no hará lo que crees que debería hacer!

Si se piensa en ello da:

instance MyClass a => Show a where 
    show = myShow 

instance HisClass a => Show a where 
    show = hisShow 

la que debe recoger el compilador?

Su módulo solo puede definir uno de estos, pero el código de usuario final importará un grupo de módulos, no solo el suyo.Además, si otro módulo define

instance Show HisDataTypeThatHasNeverHeardOfMyClass 

el compilador estaría bien dentro de sus derechos a ignorar a su instancia y tratar de usar el suyo.

La respuesta correcta, por desgracia, es hacer dos cosas.

Para cada individuo instancia de MyClass puede definir una instancia correspondiente del Show con la definición muy mecánico

instance MyClass Foo where ... 

instance Show Foo where 
    show = myShow 

Esto es bastante desafortunado, pero funciona bien cuando hay sólo unos pocos casos de MiClase menores consideración.

Cuando tiene un gran número de instancias, la forma de evitar la duplicación de código (para cuando la clase es considerablemente más complicada que mostrar) es definir.

newtype WrappedMyClass a = WrapMyClass { unwrapMyClass :: a } 

instance MyClass a => Show (WrappedMyClass a) where 
    show (WrapMyClass a) = myShow a 

Esto proporciona el newtype como vehículo para despacho de instancia. y luego

instance Foo a => Show (WrappedFoo a) where ... 
instance Bar a => Show (WrappedBar a) where ... 

es inequívoca, debido a que los 'patrones' de tipo para WrappedFoo a y WrappedBar a son disjuntos.

Hay una serie de ejemplos de este modismo en el paquete base.

En Control.Applicative hay definiciones para WrappedMonad y WrappedArrow por esta misma razón.

Lo ideal sería que usted sería capaz de decir:

instance Monad t => Applicative t where 
    pure = return 
    (<*>) = ap 

pero con eficacia este caso lo que está diciendo es que cada Aplicativo debe ser derivado al encontrar primero una instancia para la Mónada, y luego despachar a ella. Entonces, si bien tendría la intención de decir que cada mónada es aplicable (por cierto, como dice la implicación, como =>), lo que dice es que cada aplicante es una mónada, porque tener un encabezado de instancia 't' coincide con cualquier tipo. En muchos sentidos, la sintaxis para las definiciones de 'instancia' y 'clase' es al revés.

Answer 5

Usted puede encontrar algunas respuestas interesantes en un SO pregunta relacionada: Linking/Combining Type Classes in Haskell

Answer 6

Como Ed Kmett señaló, esto no es posible en absoluto para su caso. Sin embargo, si usted tiene acceso a la clase que desea proporcionar una instancia predeterminada, usted puede reducir el repetitivo al mínimo con una implementación por defecto y restringir el tipo de entrada con la firma predeterminada que necesita:

{-# LANGUAGE DefaultSignatures #-} 

class MyClass a where 
    someFunc :: a -> Int 

class MyShow a where 
    myShow :: a -> String 
    default myShow :: MyClass a => a -> String 
    myShow = show . someFunc 

instance MyClass Int where 
    someFunc i = i 

instance MyShow Int 

main = putStrLn (myShow 5) 

Tenga en cuenta que la única repetición real (bueno, aparte de todo el ejemplo) reducida a instance MyShow Int.

Consulte aeson s ToJSON para obtener un ejemplo más realista.