Haskell Language
Modules
Recherche…
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
Haskell prend en charge les modules:
un module peut exporter tout ou un sous-ensemble de ses types et fonctions membres
un module peut "réexporter" les noms importés d'autres modules
Du côté consommateur d'un module, on peut:
importer tout ou un sous-ensemble des membres du module
masquer les importations d'un membre particulier ou d'un ensemble de membres
haskell.org a un excellent chapitre sur la définition des modules.
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.