modèle de données Normalisé et immuable

Question

Comment Haskell résoudre le problème « structure de données normalisée immuable »?

Par exemple, considérons une structure de données représentant les ex petites amies/petits amis:

data Man = Man {name ::String, exes::[Woman]} 

data Woman = Woman {name :: String, exes::[Man]} 

Qu'advient-il si une femme change son nom et elle avait été avec 13 l'homme? Alors tout l'homme devrait être "mis à jour" (au sens de Haskell) aussi? Une sorte de normalisation est nécessaire pour éviter ces "mises à jour".

Ceci est un exemple très simple, mais imaginez un modèle avec 20 entités et les relations arbitraires entre eux, quoi faire alors?

Quelle est la méthode recommandée pour représenter des données complexes, normalisées dans une langue immuable?

Par exemple, une solution Scala se trouvent here (voir code ci-dessous), et il utilise des références. Que faire à Haskell?

class RefTo[V](val target: ModelRO[V], val updated: V => AnyRef) { 
    def apply() = target() 
} 

Je me demande, si des solutions plus générales comme celle-ci (en Scala) ne fonctionnent pas dans Haskell ou ils ne sont pas nécessaires? Si elles ne fonctionnent pas, alors pourquoi pas? J'ai essayé de chercher des bibliothèques qui le font dans Haskell mais elles ne semblent pas exister. En d'autres termes, si je veux modéliser une base de données SQL normalisée dans Haskell (par exemple pour être utilisé avec acid-state) existe-t-il un moyen général de décrire les clés étrangères? En général, je veux dire, ne pas coder à la main les identifiants comme suggéré par chepner dans les commentaires ci-dessous.

EDIT:

Pourtant, autrement dit, est-il une bibliothèque (pour Haskell ou Scala) qui implémente une base de données SQL/relationnelle en mémoire (éventuellement en utilisant l'approvisionnement de l'événement pour la persistance) de telle sorte que la base de données est immuable et la plupart des opérations SQL (query/join/insert/delete/etc.) sont implémentées et sont sécurisées. S'il n'y a pas une telle bibliothèque, pourquoi pas? Cela semble être une très bonne idée. Comment devrais-je créer une telle bibliothèque?

EDIT 2:

Quelques liens connexes:

• https://realm.io/news/slug-peter-livesey-managing-consistency-immutable-models/
• https://tonyhb.gitbooks.io/redux-without-profanity/content/normalizer.html
• https://github.com/agentm/project-m36
• https://github.com/scalapenos/stamina
• http://www.haskellforall.com/2014/12/a-very-general-api-for-relational-joins.html

Answer 1

Le problème est que vous stockez des données et des relations dans le même type. Pour normaliser, vous devez séparer. Bases de données relationnelles 101.

newtype Id a = Id Int -- Type-safe ID. 
data Person = Person { id :: Id Person, name :: String } 
data Ex = Ex { personId :: Id Person, exId :: Id Person } 

Maintenant, si une personne change son nom, une seule valeur Person est affectée. Les entrées Ex ne se soucient pas des noms des peuples.

Answer 2

Le projet M63 vient plutôt close à ce que je cherchais. Il est écrit en Haskell.

Une solution Haskell plus légère est décrite dans le poste de Gabriel Gonzalez "A very general API for relational joins".