Haskell Language
moduler

Syntax

• modul Namn vart - exportera alla namn som deklarerats i den här filen

• modul Namn (functionOne, Type (..)) där - endast exportera functionOne, Type och Type's konstruktörer

• importmodul - importera alla modulens exporterade namn

• importera kvalificerad modul som MN - kvalificerad import

• importmodul (justThisFunction) - importera bara vissa namn från en modul

• importmodul gömmer sig (funktionsnamn, typ) - importera alla namn från en modul utom funktionens namn och typ

Anmärkningar

Definiera din egen modul

Om vi har en fil som heter Business.hs kan vi definiera en Business som kan import , som så:

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

En djupare hierarki är naturligtvis möjligt; se exempel på hierarkiska modulnamn .

Exportera konstruktörer

För att exportera typen och alla dess konstruktörer måste man använda följande syntax:

module X (Person (..)) where

Så för följande definitioner på toppnivå i en fil som heter People.hs :

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

isFoe Foe = True
isFoe _   = False

Denna moduldeklaration högst upp:

module People (Person (..)) where

skulle bara exportera Person och dess konstruktörer Friend and Foe .

Om exportlistan som följer modulens nyckelord utelämnas, kommer alla namn som är bundna på den översta nivån i modulen att exporteras:

module People where

skulle exportera Person , dess konstruktörer och isFoe funktionen.

Importera specifika medlemmar i en modul

Haskell stöder import av en delmängd av objekt från en modul.

import qualified Data.Stream (map) as D

skulle bara importera map från Data.Stream , och samtal till den här funktionen kräver D. .:

D.map odd [1..]

annars kompilatorn kommer att försöka använda Prelude 's map

Dölja import

Prelude definierar ofta funktioner vars namn används någon annanstans. Om du inte döljer sådan import (eller använder kvalificerad import där det inträffar konflikter) orsakar kompilationsfel.

Data.Stream definierar funktioner som heter map , head och tail som normalt kolliderar med de som definieras i Prelude. Vi kan dölja importen från Prelude genom att hiding :

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

I verkligheten kräver det för mycket kod för att dölja Prelude-sammanstötningar så här, så du skulle i själva verket använda en qualified import av Data.Stream istället.

Kvalificerande import

När flera moduler definierar samma funktioner med namn klagar kompilatorn. I sådana fall (eller för att förbättra läsbarheten) kan vi använda en qualified import:

import qualified Data.Stream as D

Nu kan vi förhindra tvetydighetskompilatorfel när vi använder map , som definieras i Prelude och Data.Stream :

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

Det är också möjligt att importera en modul med endast de sammanstötande namnen som är kvalificerade via import Data.Text as T , vilket gör att man kan ha Text istället för T.Text etc.

Hierarkiska modulnamn

Modulernas namn följer filsystemets hierarkiska struktur. Med följande fillayout:

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

modulhuvudena ser ut så här:

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

Anteckna det:

• modulnamnet baseras på sökvägen för filen som förklarar modulen
• Mappar kan dela ett namn med en modul, vilket ger en naturligt hierarkisk namnstruktur till moduler