Haskell Language
Module
Suche…
Syntax
Modulname Dabei werden alle in dieser Datei deklarierten Namen exportiert
Modulname (functionOne, Type (..)) wobei - nur Konstruktoren von functionOne, Type und Type exportieren
Modul importieren - Importieren Sie alle exportierten Namen des Moduls
qualifiziertes Modul als MN-qualifizierter Import importieren
import Module (justThisFunction) - Importiert nur bestimmte Namen aus einem Modul
import Modul ausblenden (functionName, Type) - Importiert alle Namen eines Moduls mit Ausnahme von functionName und Type
Bemerkungen
Haskell unterstützt Module:
Ein Modul kann alle oder einen Teil seiner Member-Typen und -Funktionen exportieren
Ein Modul kann Namen "reexportieren", die es aus anderen Modulen importiert hat
Auf der Consumer-Seite eines Moduls kann man:
alle importieren oder eine Teilmenge der Modulmitglieder
Importe eines bestimmten Mitglieds oder einer Gruppe von Mitgliedern ausblenden
haskell.org hat ein großartiges Kapitel zur Definition von Modulen.
Eigenes Modul definieren
Wenn wir eine Datei namens Business.hs
, können wir ein Business
Modul definieren, das import
kann.
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
Eine tiefere Hierarchie ist natürlich möglich; Siehe das Beispiel für hierarchische Modulnamen .
Konstruktoren exportieren
Um den Typ und alle seine Konstruktoren zu exportieren, muss die folgende Syntax verwendet werden:
module X (Person (..)) where
Also für die folgenden Top-Level-Definitionen in einer Datei namens People.hs
:
data Person = Friend String | Foe deriving (Show, Eq, Ord)
isFoe Foe = True
isFoe _ = False
Diese Moduldeklaration oben:
module People (Person (..)) where
würde nur Person
und seine Konstrukteure Friend
und Foe
exportieren.
Wenn die Exportliste, die auf das Modulschlüsselwort folgt, nicht angegeben wird, werden alle auf der obersten Ebene des Moduls gebundenen Namen exportiert:
module People where
würde Person
, seine Konstruktoren und die isFoe
Funktion isFoe
.
Bestimmte Mitglieder eines Moduls importieren
Haskell unterstützt den Import einer Teilmenge von Elementen aus einem Modul.
import qualified Data.Stream (map) as D
würde nur die map
aus Data.Stream
, und Aufrufe dieser Funktion würden D.
erfordern:
D.map odd [1..]
Andernfalls versucht der Compiler, die map
Funktion von Prelude
zu verwenden.
Importe ausblenden
Prelude definiert häufig Funktionen, deren Namen anderswo verwendet werden. Wenn Sie solche Importe nicht verbergen (oder qualifizierte Importe verwenden, wenn Konflikte auftreten), werden Kompilierungsfehler verursacht.
Data.Stream
definiert Funktionen namens map
, head
und tail
die normalerweise mit den in Prelude definierten zusammenstoßen. Wir können diese Importe von Prelude ausblenden, hiding
wir sie ausblenden:
import Data.Stream -- everything from Data.Stream
import Prelude hiding (map, head, tail, scan, foldl, foldr, filter, dropWhile, take) -- etc
In der Realität wäre zu viel Code erforderlich, um Prelude-Kollisionen wie diese zu verbergen, sodass Sie stattdessen einen qualified
Import von Data.Stream
verwenden.
Qualifizierende Importe
Wenn mehrere Module die gleichen Funktionen anhand des Namens definieren, wird der Compiler dies bemängeln. In solchen Fällen (oder zur Verbesserung der Lesbarkeit) können wir einen qualified
Import verwenden:
import qualified Data.Stream as D
Jetzt können wir Mehrdeutigkeits-Compiler-Fehler vermeiden, wenn wir map
, die in Prelude
und Data.Stream
:
map (== 1) [1,2,3] -- will use Prelude.map
D.map (odd) (fromList [1..]) -- will use Data.Stream.map
Es ist auch möglich, ein Modul zu importieren, bei dem nur die import Data.Text as T
Namen über import Data.Text as T
qualifiziert werden, wodurch Text
anstelle von T.Text
usw. verwendet werden kann.
Hierarchische Modulnamen
Die Namen der Module folgen der hierarchischen Struktur des Dateisystems. Mit folgendem Dateilayout:
Foo/
├── Baz/
│ └── Quux.hs
└── Bar.hs
Foo.hs
Bar.hs
Die Modulheader würden so aussehen:
-- 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
Beachten Sie, dass:
- Der Modulname basiert auf dem Pfad der Datei, die das Modul deklariert
- Ordner können einen Namen mit einem Modul teilen, wodurch den Modulen eine natürlich hierarchische Namensstruktur gegeben wird