Haskell Language
modules

Syntaxis

• module Naam waar - exporteer alle namen die in dit bestand zijn gedeclareerd

• module Naam (functionOne, Type (..)) waar - exporteer alleen de constructors van functionOne, Type en Type

• import Module - importeer alle geëxporteerde namen van modules

• gekwalificeerde module importeren als MN - gekwalificeerde import

• importmodule (justThisFunction) - importeer alleen bepaalde namen uit een module

• module verbergen (functionName, Type) - importeer alle namen uit een module behalve functionName en Type

Opmerkingen

Uw eigen module definiëren

Als we een bestand met de naam Business.hs , kunnen we een Business module definiëren die als volgt kan worden import :

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

Een diepere hiërarchie is natuurlijk mogelijk; zie het voorbeeld van de hiërarchische modulenamen .

Constructeurs exporteren

Om het type en al zijn constructors te exporteren, moet men de volgende syntaxis gebruiken:

module X (Person (..)) where

Dus voor de volgende definities op het hoogste niveau in een bestand met de naam People.hs :

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

isFoe Foe = True
isFoe _   = False

Deze module verklaring bovenaan:

module People (Person (..)) where

zou alleen Person en zijn constructeurs Friend and Foe exporteren.

Als de exportlijst na het trefwoord van de module wordt weggelaten, worden alle namen op het hoogste niveau van de module geëxporteerd:

module People where

zou Person , zijn constructeurs en de isFoe functie isFoe .

Specifieke leden van een module importeren

Haskell ondersteunt het importeren van een subset items uit een module.

import qualified Data.Stream (map) as D

zou alleen de map importeren uit Data.Stream en voor deze functie is D. vereist:

D.map odd [1..]

anders zal de compiler probeert te gebruiken Prelude 's map functie.

Invoer verbergen

Prelude definieert vaak functies waarvan de namen elders worden gebruikt. Het niet verbergen van dergelijke invoer (of het gebruik van gekwalificeerde invoer waar botsingen optreden) zal compilatiefouten veroorzaken.

Data.Stream definieert functies met de naam map , head en tail die normaal gesproken botsen met die gedefinieerd in Prelude. We kunnen die invoer uit Prelude hiding met behulp van hiding :

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

In werkelijkheid zou het teveel code vereisen om Prelude-botsingen als deze te verbergen, dus zou u in plaats daarvan een qualified import van Data.Stream gebruiken.

In aanmerking komende importen

Wanneer meerdere modules dezelfde functies op naam definiëren, zal de compiler klagen. In dergelijke gevallen (of om de leesbaarheid te verbeteren) kunnen we een qualified import gebruiken:

import qualified Data.Stream as D

Nu kunnen we fouten bij het compileren van ambiguïteit voorkomen wanneer we map , die is gedefinieerd in Prelude en Data.Stream :

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

Het is ook mogelijk om een module te importeren waarbij alleen de botsende namen worden gekwalificeerd via import Data.Text as T , waardoor men Text kan hebben in plaats van T.Text enz.

Hiërarchische modulenamen

De namen van modules volgen de hiërarchische structuur van het bestandssysteem. Met de volgende bestandsindeling:

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

de module headers zouden er zo uitzien:

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

Let daar op:

• de modulenaam is gebaseerd op het pad van het bestand dat de module aangeeft
• Mappen kunnen een naam delen met een module, wat modules een natuurlijk hiërarchische naamstructuur geeft