Me encuentro con un problema comúnmente, cuando escribo programas más grandes en Haskell. A menudo me encuentro con ganas de múltiples tipos distintos que comparten una representación interna y varias operaciones centrales.

Hay dos enfoques relativamente obvios para resolver este problema.

Uno está usando una clase de tipo y elGeneralizedNewtypeDeriving extensión. Ponga suficiente lógica en una clase de tipo para soportar las operaciones compartidas que el caso de uso desee. Cree un tipo con la representación deseada y cree una instancia de la clase de tipo para ese tipo. Luego, para cada caso de uso, cree envoltorios para él con newtype y derive la clase común.

La otra es declarar el tipo con una variable de tipo fantasma y luego usarEmptyDataDecls para crear tipos distintos para cada caso de uso diferente.

Mi principal preocupación no es mezclar valores que compartan representación interna y operaciones, sino que tengan diferentes significados en mi código. Ambos enfoques resuelven ese problema, pero se sienten significativamente torpes. Mi segunda preocupación es reducir la cantidad de repetitivo requerida, y ambos enfoques funcionan lo suficientemente bien.

¿Cuáles son las ventajas y desventajas de cada enfoque? ¿Existe una técnica que se acerque a hacer lo que quiero, proporcionar seguridad de tipo sin código repetitivo?