Haskell Language
Modules

Syntaxe

• Nom du module où - exporte tous les noms déclarés dans ce fichier

• Nom du module (functionOne, Type (..)) où - exporte uniquement les constructeurs functionOne, Type et Type

• import module - Importer tous les noms exportés du module

• importer un module qualifié en tant que MN - importation qualifiée

• import Module (justThisFunction) - Importer uniquement certains noms d'un module

• import Module masquant (functionName, Type) - Importer tous les noms d'un module à l'exception de NomFonction et Type

Remarques

Définir votre propre module

Si nous avons un fichier appelé Business.hs , nous pouvons définir un module Business pouvant être import , comme ceci:

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

Une hiérarchie plus profonde est bien sûr possible; voir l'exemple des noms de modules hiérarchiques .

Exportateurs Constructeurs

Pour exporter le type et tous ses constructeurs, il faut utiliser la syntaxe suivante:

module X (Person (..)) where

Donc, pour les définitions de niveau supérieur suivantes dans un fichier appelé People.hs :

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

isFoe Foe = True
isFoe _   = False

Cette déclaration de module en haut:

module People (Person (..)) where

ne ferait qu'exporter Person et ses constructeurs Friend and Foe .

Si la liste d'export suivant le mot-clé module est omise, tous les noms liés au niveau supérieur du module seront exportés:

module People where

exporterait Person , ses constructeurs et la fonction isFoe .

Importation de membres spécifiques d'un module

Haskell prend en charge l'importation d'un sous-ensemble d'éléments à partir d'un module.

import qualified Data.Stream (map) as D

importerait uniquement la map de Data.Stream , et les appels à cette fonction nécessiteraient D. .:

D.map odd [1..]

Sinon, le compilateur essaiera d'utiliser la fonction de map Prelude .

Cacher les importations

Le prélude définit souvent des fonctions dont les noms sont utilisés ailleurs. Le fait de ne pas cacher ces importations (ou d’utiliser des importations qualifiées en cas de conflit) provoquera des erreurs de compilation.

Data.Stream définit les fonctions nommées map , head et tail qui sont normalement incompatibles avec celles définies dans Prelude. On peut cacher ces importations de Prelude en se hiding :

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

En réalité, cela nécessiterait trop de code pour masquer des conflits de type Prelude, de sorte que vous utiliseriez en fait une importation qualified de Data.Stream .

Importations admissibles

Lorsque plusieurs modules définissent les mêmes fonctions par leur nom, le compilateur se plaindra. Dans de tels cas (ou pour améliorer la lisibilité), nous pouvons utiliser une importation qualified :

import qualified Data.Stream as D

Maintenant, nous pouvons éviter les erreurs d'ambiguïté du compilateur lorsque nous utilisons la map , qui est définie dans Prelude et Data.Stream :

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

Il est également possible d'importer un module avec seulement les noms en import Data.Text as T qualifiés via l' import Data.Text as T , ce qui permet d'avoir Text au lieu de T.Text etc.

Noms de modules hiérarchiques

Les noms des modules suivent la structure hiérarchique du système de fichiers. Avec la disposition de fichier suivante:

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

les en-têtes de module ressembleraient à ceci:

-- 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

Notez que:

• le nom du module est basé sur le chemin du fichier déclarant le module
• Les dossiers peuvent partager un nom avec un module, ce qui donne une structure de nommage naturellement hiérarchique aux modules.