Haskell Language
Módulos

Sintaxis

• Nombre del módulo donde - exportar todos los nombres declarados en este archivo

• Nombre del módulo (functionOne, Type (..)) donde - exportar solo los constructores de functionOne, Type y Type

• Importar módulo - importar todos los nombres exportados del módulo

• importar módulo calificado como MN - importación calificada

• Módulo de importación (justThisFunction): importa solo ciertos nombres de un módulo

• Importar ocultación del módulo (functionName, Type): importa todos los nombres de un módulo, excepto functionName y Type

Observaciones

Definiendo tu propio módulo

Si tenemos un archivo llamado Business.hs , podemos definir un módulo de Business que se puede import , por ejemplo:

module Business (
    Person (..), -- ^ Export the Person type and all its constructors and field names
    employees   -- ^ Export the employees function
) where
-- begin types, function definitions, etc

Una jerarquía más profunda es, por supuesto, posible; vea el ejemplo de los nombres de módulos jerárquicos .

Constructores exportadores

Para exportar el tipo y todos sus constructores, uno debe usar la siguiente sintaxis:

module X (Person (..)) where

Entonces, para las siguientes definiciones de nivel superior en un archivo llamado People.hs :

data Person = Friend String | Foe deriving (Show, Eq, Ord)

isFoe Foe = True
isFoe _   = False

Este módulo de declaración en la parte superior:

module People (Person (..)) where

Solo exportaría Person y sus constructores Friend y Foe .

Si se omite la lista de exportación que sigue a la palabra clave del módulo, se exportarán todos los nombres vinculados en el nivel superior del módulo:

module People where

Exportaría Person , sus constructores y la función isFoe .

Importación de miembros específicos de un módulo

Haskell admite la importación de un subconjunto de elementos de un módulo.

import qualified Data.Stream (map) as D

solo importaría el map desde Data.Stream , y las llamadas a esta función requerirían D. .:

D.map odd [1..]

de lo contrario, el compilador intentará usar la función de map Prelude .

Ocultar Importaciones

Prelude a menudo define funciones cuyos nombres se usan en otros lugares. Si no se ocultan dichas importaciones (o se utilizan importaciones calificadas donde se producen conflictos) se producirán errores de compilación.

Data.Stream define funciones denominadas map , head y tail que normalmente chocan con las definidas en Prelude. Podemos ocultar esas importaciones de Prelude usando la hiding :

import Data.Stream -- everything from Data.Stream
import Prelude hiding (map, head, tail, scan, foldl, foldr, filter, dropWhile, take) -- etc

En realidad, se requeriría demasiado código para ocultar los choques de Prelude de esta manera, por lo que de hecho utilizaría una importación qualified de Data.Stream en Data.Stream lugar.

Importaciones Calificadas

Cuando varios módulos definen las mismas funciones por nombre, el compilador se quejará. En tales casos (o para mejorar la legibilidad), podemos utilizar una importación qualified :

import qualified Data.Stream as D

Ahora podemos evitar los errores del compilador de ambigüedad cuando usamos map , que se define en Prelude y Data.Stream :

map (== 1) [1,2,3] -- will use Prelude.map
D.map (odd) (fromList [1..]) -- will use Data.Stream.map

También es posible importar un módulo con solo los nombres de conflicto calificados a través de import Data.Text as T , lo que permite tener Text lugar de T.Text etc.

Nombres de módulos jerárquicos

Los nombres de los módulos siguen la estructura jerárquica del sistema de archivos. Con el siguiente diseño de archivo:

Foo/
├── Baz/
│   └── Quux.hs
└── Bar.hs
Foo.hs
Bar.hs

Los encabezados del módulo se verían así:

-- file Foo.hs
module Foo where

-- file Bar.hs
module Bar where

-- file Foo/Bar.hs
module Foo.Bar where

-- file Foo/Baz/Quux.hs
module Foo.Baz.Quux where

Tenga en cuenta que:

• El nombre del módulo se basa en la ruta del archivo que declara el módulo.
• Las carpetas pueden compartir un nombre con un módulo, lo que da una estructura de denominación jerárquica natural a los módulos