Haskell Language
moduli

Sintassi

• modulo Nome dove - esporta tutti i nomi dichiarati in questo file

• nome modulo (functionOne, Type (..)) dove - esportare solo i costruttori functionOne, Type e Type

• modulo di importazione: importa tutti i nomi esportati del modulo

• importare Modulo qualificato come MN - importazione qualificata

• import Module (justThisFunction) - importa solo determinati nomi da un modulo

• import Module hiding (functionName, Type) - importa tutti i nomi da un modulo ad eccezione di functionName e Type

Osservazioni

Definire il tuo modulo

Se abbiamo un file chiamato Business.hs , possiamo definire un modulo Business che può essere import , in questo modo:

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 gerarchia più profonda è ovviamente possibile; vedere l'esempio dei nomi dei moduli gerarchici .

Esportare costruttori

Per esportare il tipo e tutti i suoi costruttori, si deve usare la seguente sintassi:

module X (Person (..)) where

Pertanto, per le seguenti definizioni di livello superiore in un file denominato People.hs :

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

isFoe Foe = True
isFoe _   = False

Questa dichiarazione del modulo in alto:

module People (Person (..)) where

esporterebbe solo Person e i suoi costruttori Friend e Foe .

Se viene omessa la lista di esportazione che segue la parola chiave del modulo, verranno esportati tutti i nomi associati al livello più alto del modulo:

module People where

isFoe Person , i suoi costruttori e la funzione isFoe .

Importazione di membri specifici di un modulo

Haskell supporta l'importazione di un sottoinsieme di elementi da un modulo.

import qualified Data.Stream (map) as D

importerebbe solo la map da Data.Stream e le chiamate a questa funzione richiederebbero D. .:

D.map odd [1..]

altrimenti il ​​compilatore proverà ad usare la funzione map Prelude .

Nascondere le importazioni

Il preludio definisce spesso funzioni i cui nomi sono usati altrove. Non nascondendo tali importazioni (o utilizzando importazioni qualificate in cui si verificano conflitti) causerà errori di compilazione.

Data.Stream definisce le funzioni denominate map , head e tail che normalmente si scontrano con quelle definite in Prelude. Possiamo nascondere quelle importazioni da Prelude usando il hiding :

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

In realtà, richiederebbe un numero eccessivo di codice per nascondere le Data.Stream di Preludio in questo modo, quindi in effetti si utilizzerà invece un'importazione qualified di Data.Stream .

Importazioni qualificate

Quando più moduli definiscono le stesse funzioni per nome, il compilatore si lamenterà. In questi casi (o per migliorare la leggibilità), possiamo usare un'importazione qualified :

import qualified Data.Stream as D

Ora possiamo evitare errori del compilatore di ambiguità quando usiamo la map , che è definita in Prelude e Data.Stream :

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

È anche possibile importare un modulo con solo i nomi in conflitto che vengono qualificati tramite import Data.Text as T , che consente di avere Text anziché T.Text ecc.

Nomi dei moduli gerarchici

I nomi dei moduli seguono la struttura gerarchica del filesystem. Con il seguente layout di file:

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

le intestazioni del modulo sarebbero simili a questo:

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

Nota che:

• il nome del modulo si basa sul percorso del file che dichiara il modulo
• Le cartelle possono condividere un nome con un modulo, che dà una struttura di denominazione gerarchica ai moduli