Haskell recursivo/definiciones de módulos circulares?

Question

Tengo dos módulos que se importan entre sí. Haskell no admite módulos recursivos. Entonces, ¿cómo puedo reescribir mis tipos de datos sin necesidad de un sistema circular de módulos?

Aquí está mi Character.hs

module Character where 
import ItemSystem 

data Character = Character { name :: String, items :: [Item] } 

Aquí está una ItemSystem.hs

module Item where 
import Character 

data ItemEffect = CharacterEffect (Character -> Character) 
       | ItemEffect  (Item -> Item) 

data Item = Item { name :: String, weight :: Int, effect :: ItemEffect } 

ACTUALIZACIÓN:. Voy a escribir mis todos los tipos de datos en un módulo :(

Answer 1

Crear una tercer módulo para las partes mutuamente dependientes:

module Internal where 

data Character = Character { name :: String, items :: [Item] } 

data ItemEffect = CharacterEffect (Character -> Character) 
       | ItemEffect  (Item -> Item) 

data Item = Item { name :: String, weight :: Int, effect :: ItemEffect } 

A continuación, importarlo de los otros dos módulos y, opcionalmente, volver a exportar el material que desea disponible de cada uno:

module Character (Character(..), {- etc -}) where 

import Internal 

-- non-mutually dependent stuff 

module Item (Item(..), ItemEffect(..), {- etc -}) where 

import Internal 

-- non-mutually dependent stuff 

Si esto es en un paquete de Cabal, a continuación, puede ocultar el módulo de Internal del resto del mundo poniéndolo en la sección Other-modules en lugar de Exported-modules.

_{Para completar: GHC does support mutually recursive modules, pero no lo recomendaría para casos simples como este.}

Answer 2

Opción 1: Como se sugirió, sugiera las partes mutuamente dependientes en su propio módulo.

Opción 2: poner todo en el mismo módulo.

Opción 3: Si está utilizando GHC, puede crear un archivo hs-boot para uno de sus módulos y hacer que el otro módulo lo importe con un pragma {-# SOURCE #-}.