Ispezione Haskell Typeclass

Question

Vorrei utilizzare haskell per implementare un gioco e vorrei utilizzare un sistema di classi di tipi per implementare il sistema di articoli. Avrebbe funzionato o meno così:

data Wood = Wood Int 

instance Item Wood where 
    image a = "wood.png" 
    displayName a = "Wood" 

instance Flammable Wood where 
    burn (Wood health) | health' <= 0 = Ash 
        | otherwise = Wood health' 
     where health' = health - 100 

dove la voce e le classi infiammabili sono qualcosa di simile:

class Item a where 
    image :: a -> String 
    displayName :: a -> String 

class Flammable a where 
    burn :: (Item b) => a -> b 

Per fare questo, avrei bisogno di un modo per rilevare se un valore è un'istanza di una classe di tipo.

Il modulo Data.Data offre una funzionalità simile che mi consente di credere che ciò sia possibile.

Answer 1

Le classi di tipo sono probabilmente il modo sbagliato di andare qui. Considerare l'utilizzo di tipi di dati algebrici semplici, invece, ad esempio:

data Item = Wood Int | Ash 

image Wood = "wood.png" 
image Ash = ... 

displayName Wood = "Wood" 
displayName Ash = "Ash" 

burn :: Item -> Maybe Item 
burn (Wood health) | health' <= 0 = Just Ash 
        | otherwise = Just (Wood health') 
    where health' = health - 100 
burn _ = Nothing -- Not flammable 

Se questo lo rende troppo difficile aggiungere nuovi elementi, è possibile invece di codificare le operazioni nel tipo di dati in sé.

data Item = Item { image :: String, displayName :: String, burn :: Maybe Item } 

ash :: Item 
ash = Item { image = "...", displayName = "Ash", burn :: Nothing } 

wood :: Int -> Item 
wood health = Item { image = "wood.png", displayName = "Wood", burn = Just burned } 
    where burned | health' <= 0 = ash 
       | otherwise = wood health' 
      health' = health - 100 

Tuttavia, questo rende più difficile aggiungere nuove funzioni. Il problema di eseguire entrambi allo stesso tempo è noto come expression problem. C'è uno nice lecture on Channel 9 by Dr. Ralf Lämmel dove spiega questo problema in modo più approfondito e discute varie non-soluzioni, vale la pena controllare se hai tempo.

Ci sono degli approcci per risolverlo, ma sono considerevolmente più complessi dei due progetti che ho illustrato, quindi raccomando di usare uno di questi se soddisfa le tue esigenze, e non preoccuparti del problema dell'espressione a meno che tu non debba .

Answer 2

Ecco il problema:

burn :: (Item b) => a -> b 

Ciò significa che il valore del risultato di burn deve essere polimorfico. Deve essere in grado di riempire qualsiasi buco per qualsiasi istanza di Item.

Ora, è abbastanza evidente che si sta cercando di scrivere qualcosa di simile (in linguaggio OO immaginario con interfacce e sottoclassi):

Interface Item { 
    String getImage(); 
    String getDisplayName(); 
} 

Interface Flammable { 
    Item burn(); 
} 

In questa sorta di codice, stai dicendo che burn produrrà qualche articolo, senza alcuna garanzia circa che tipo dell'articolo è. Questa è la differenza tra "per tutti" e "esiste". Quello che volevi esprimere nel codice Haskell era "esiste", ma ciò che hai espresso in realtà era "per tutti".

Ora se sei davvero sicuro di voler fare "esiste" la funzionalità, puoi dare un'occhiata usando Existential Types. Ma attenzione. Se avete intenzione di scrivere codice come questo:

if (foo instanceof Flammable) { 
    ... 
} 

Poi si sono quasi certamente facendo male, e vi imbatterete in tanto dolore e l'agonia. Considera invece le alternative suggerite da hammar.