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


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow