Evitar la contaminación del espacio de nombres en Haskell

Question

Estoy usando muchos registros diferentes en un programa, algunos de ellos usan los mismos nombres de campo, p.

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

Ahora bien, como la función de acceso "foo" se define dos veces, me sale el error "Múltiples declaraciones". Una forma de evitar esto sería usar diferentes módulos que se importen completamente calificados, o simplemente cambiar el nombre de los campos (que no quiero hacer).

¿Cuál es la forma oficialmente sugerida de tratar esto en Haskell?

Answer 1

Este es un problema muy peludo. Hay varias propuestas para que arreglan el sistema de registro. En una nota relacionada, vea TDNR y related discussion on cafe.

Utilizando las funciones de idioma disponibles actualmente, creo que la mejor opción es definir los dos tipos en dos módulos diferentes y realizar una importación calificada. Además de esto, si lo desea, puede implementar algún tipo de maquinaria de clase.

En Customer.hs

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

En Product.hs

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

Mediante su uso, en Third.hs

module Third where 

import qualified Customer as C 
import qualified Product as P 

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

Sin embargo, me imagino que no será demasiado tarde antes de abordar el problema sobre recursively dependent modules.

Answer 2

(FYI, esta pregunta es casi seguro que un duplicado)

Soluciones:

1) Prefijo los campos marcados con una etiqueta que indica el tipo (muy común)

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

2) Uso las clases de tipo (menos comunes, las personas se quejan de prefijos como cFoo son inconvenientes, pero evidentemente no tan malos que escribirán una clase y una instancia o usarán TH para hacer lo mismo).

class getFoo a where 
    foo :: a -> Int 

instance getFoo Customer where 
    foo = cFoo 

3) un mejor uso de nombres de campo Si los campos son en realidad diferente (que no siempre es cierto, mi equipo tiene una edad igual que mi empleado), entonces esta es la mejor solución.

Answer 3

Véase también el paquete tiene: http://chrisdone.com/posts/duck-typing-in-haskell

y si realmente necesidad registros extensibles ahora, siempre se puede utilizar Hlist. Pero no recomendaría esto hasta que estés realmente familiarizado y cómodo con Haskell medianamente avanzado, y aun así comprobaría tres veces que lo necesitas.

Haskelldb tiene una versión ligeramente más liviano: http://hackage.haskell.org/packages/archive/haskelldb/2.1.0/doc/html/Database-HaskellDB-HDBRec.html

Y luego hay otra versión de los registros extensibles como parte de la biblioteca de pomelo FRP: http://hackage.haskell.org/package/grapefruit-records

Una vez más, para sus fines, estaría de tripas y simplemente cambie el nombre de los campos. Pero estas referencias son para mostrar que cuando realmente se necesita todo el poder de los registros extensibles, existen formas de hacerlo, incluso si ninguno es tan agradable como lo sería una extensión de lenguaje bien diseñada.

Answer 4

Hay una extensión de idioma DuplicateRecordFields que permite la duplicación de funciones de campo y hace que su tipo sea inferido por tipo de anotación.

Aquí hay un pequeño ejemplo (haskell-stack script):

#!/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