Éviter la pollution des espaces de noms dans Haskell

Question

J'utilise beaucoup d'enregistrements différents dans un programme, certains d'entre eux utilisant les mêmes noms de champs, par ex.

data Customer = Customer { ..., foo :: Int, ... } 
data Product = Product { ..., foo :: Int, ... } 

Maintenant que la fonction accesseur « foo » est définie, je reçois deux fois l'erreur « Plusieurs déclarations de ». Une façon d'éviter cela serait d'utiliser différents modules importés complets, ou simplement de renommer les champs (ce que je ne veux pas faire).

Quelle est la manière officiellement suggérée de gérer cela avec Haskell?

Answer 1

Ceci est un problème très poilu. Il y a plusieurs propositions pour fixant le système d'enregistrement. Sur une note connexe, voir TDNR et related discussion on cafe. En utilisant les fonctionnalités de langue actuellement disponibles, je pense que la meilleure option est de définir les deux types dans deux modules différents, et de faire une importation qualifiée. En plus de cela, si vous le souhaitez, vous pouvez implémenter des machines de type type.

Dans Customer.hs

module Customer where 
data Customer = Customer { ..., foo :: Int, ... } 

Dans Product.hs

module Product where 
data Product = Product { ..., foo :: Int, ... } 

En les utilisant, dans Third.hs

module Third where 

import qualified Customer as C 
import qualified Product as P 

.. C.foo .. 
.. P.foo .. 

Et pourtant, je pense qu'il ne sera pas trop tard avant d'avoir rencontré le problème à propos de recursively dependent modules.

Answer 2

(Pour votre information, cette question est presque certainement un double)

Solutions:

1) Prefix les champs avec une étiquette indiquant le type (très commun)

data Customer = Customer {..., cFoo :: Int, ...} 

2) Utilisation Les classes de type (moins courantes, les personnes se plaignent des préfixes comme cFoo sont peu pratiques mais évidemment pas si mauvaises qu'elles écriront une classe et une instance ou utiliseront TH pour faire la même chose).

class getFoo a where 
    foo :: a -> Int 

instance getFoo Customer where 
    foo = cFoo 

3) Utiliser de meilleurs noms de champs Si les champs sont en fait différents (ce qui est pas toujours vrai, mon ordinateur a un âge comme mon employé), alors c'est la meilleure solution.

Answer 3

Voir aussi le paquet A: http://chrisdone.com/posts/duck-typing-in-haskell

Et si vous avez vraiment besoin dossiers extensibles maintenant, vous pouvez toujours utiliser HList. Mais je ne le recommanderais pas tant que vous ne seriez pas familier et à l'aise avec Haskell moyen-avancé, et même alors, je vérifierais si vous en aviez besoin.

haskelldb a une version légèrement plus légère: http://hackage.haskell.org/packages/archive/haskelldb/2.1.0/doc/html/Database-HaskellDB-HDBRec.html

Et puis il y a une autre version des dossiers extensible dans le cadre de la bibliothèque frp de pamplemousse: http://hackage.haskell.org/package/grapefruit-records

Encore une fois, pour vos besoins, je mords la balle et renommez simplement les champs. Mais ces références doivent montrer que lorsque vous avez vraiment besoin de toute la puissance des documents extensibles, il existe des moyens de le faire, même si aucun n'est aussi agréable qu'une extension de langage bien conçue.

Answer 4

Il existe une extension de langage DuplicateRecordFields qui permet la duplication des fonctions de champ et permet de déduire son type par annotation de type.

Voici un petit exemple (script haskell-stack):

#!/usr/bin/env stack 
-- stack runghc --resolver lts-8.20 --install-ghc 

{-# LANGUAGE DuplicateRecordFields #-} 

newtype Foo = Foo { baz :: String } 
newtype Bar = Bar { baz :: String } 

foo = Foo { baz = "foo text" } 
bar = Bar { baz = "bar text" } 

main = do 
    putStrLn $ "Foo: " ++ baz (foo :: Foo) -- Foo: foo text 
    putStrLn $ "Bar: " ++ baz (bar :: Bar) -- Bar: bar text