Estoy trabajando en el diseño de una aplicación web más grande con Haskell. Esto es puramente para mi educación e interés.

Estoy comenzando escribiendo mis objetos de dominio / valor. Un ejemplo es un usuario. Esto es lo que se me ocurrió hasta ahora

module Model (User) where

class Audited a where
    creationDate :: a -> Integer
    lastUpdatedDate :: a -> Integer
    creationUser :: a -> User
    lastUpdatedUser :: a -> User

class Identified a where
    id :: a -> Integer

data User = User { userId :: Integer
                 , userEmail :: String
                 , userCreationDate :: Integer
                 , userLastUpdatedDate :: Integer
                 , userCreationUser :: User
                 , userLastUpdatedUser :: User
                 }

instance Identified User where
    id u = userId u 

instance Audited User where
    creationDate u = userCreationDate
    lastUpdatedDate u = userLastUpdatedDate
    creationUser u = userCreationUser
    lastUpdatedUser u = userLastUpdatedUser

Mi aplicación tendrá aproximadamente 20 tipos como el tipo anterior. Cuando digo "me gusta el tipo anterior", quiero decir que tendrán una identificación, información de auditoría y alguna información específica del tipo (como correo electrónico en el caso del Usuario).

o que no puedo entender es el hecho de que cada uno de mis campos (por ejemplo, User.userEmail) crea una nueva funciónfieldName :: Type -> FieldType. Con 20 tipos diferentes, el espacio de nombres parece que se llenará bastante rápido. Además, no me gusta tener que nombrar mi campo de ID de usuariouserId. Prefiero nombrarloid. ¿Hay alguna forma de evitar esto?

Tal vez debería mencionar que vengo del mundo imperativo, por lo que este material de FP es bastante nuevo (pero bastante emocionante) para mí.