Haskell Language
Moduły

Składnia

• nazwa modułu gdzie - eksportuj wszystkie nazwy zadeklarowane w tym pliku

• nazwa modułu (functionOne, Type (..)) gdzie - eksportuj tylko konstruktory functionOne, Type i Type

• import Module - importuj wszystkie wyeksportowane nazwy Module

• import kwalifikowany moduł jako MN - import kwalifikowany

• import Module (justThisFunction) - importuj tylko niektóre nazwy z modułu

• import Ukrywanie modułów (functionName, Type) - importuj wszystkie nazwy z modułu oprócz funkcji FunctionName and Type

Uwagi

Definiowanie własnego modułu

Jeśli mamy plik o nazwie Business.hs , możemy zdefiniować moduł Business , który można import , w następujący sposób:

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

Głębsza hierarchia jest oczywiście możliwa; zobacz przykład nazw hierarchicznych modułów .

Eksportowanie konstruktorów

Aby wyeksportować typ i wszystkie jego konstruktory, należy użyć następującej składni:

module X (Person (..)) where

Tak więc dla następujących definicji najwyższego poziomu w pliku o nazwie People.hs :

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

isFoe Foe = True
isFoe _   = False

Ta deklaracja modułu u góry:

module People (Person (..)) where

eksportowałby tylko Person i jej konstruktorów Friend i Foe .

Jeśli lista eksportu po słowie kluczowym modułu zostanie pominięta, wszystkie nazwy powiązane na najwyższym poziomie modułu zostaną wyeksportowane:

module People where

wyeksportuje Person , jego konstruktorów i funkcję isFoe .

Importowanie określonych członków modułu

Haskell obsługuje importowanie podzbioru elementów z modułu.

import qualified Data.Stream (map) as D

importowałby tylko map z Data.Stream , a wywołania tej funkcji wymagałyby D. .:

D.map odd [1..]

w przeciwnym razie kompilator spróbuje użyć funkcji map Prelude .

Ukrywanie importu

Preludium często definiuje funkcje, których nazwy są używane gdzie indziej. Nie ukrycie takiego importu (lub użycie kwalifikowanego importu w przypadku kolizji) spowoduje błędy kompilacji.

Data.Stream definiuje funkcje o nazwie map , head i tail które normalnie Data.Stream funkcjami zdefiniowanymi w Preludium. Możemy ukryć ten import przed Preludium za pomocą hiding :

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

W rzeczywistości wymagałoby to zbyt dużej ilości kodu, aby ukryć takie Data.Stream Preludium, więc zamiast tego Data.Stream qualified importu Data.Stream .

Kwalifikujący się import

Gdy wiele modułów definiuje te same funkcje według nazwy, kompilator będzie narzekał. W takich przypadkach (lub w celu poprawy czytelności) możemy użyć qualified importu:

import qualified Data.Stream as D

Teraz możemy zapobiec błędom kompilatora niejednoznaczności, gdy korzystamy z map zdefiniowanej w Prelude i Data.Stream :

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

Możliwe jest również zaimportowanie modułu, w którym tylko nazwy import Data.Text as T są kwalifikowane poprzez import Data.Text as T , co pozwala mieć Text zamiast T.Text itp.

Hierarchiczne nazwy modułów

Nazwy modułów są zgodne z hierarchiczną strukturą systemu plików. Z następującym układem pliku:

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

nagłówki modułów wyglądałyby tak:

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

Uwaga:

• nazwa modułu jest oparta na ścieżce pliku deklarującego moduł
• Foldery mogą współdzielić nazwę z modułem, co nadaje modułom naturalnie hierarchiczną strukturę nazewnictwa