Modulok
Az F# kontextusában a modul egy F#-kód, például értékek, típusok és függvényértékek csoportosítása egy F#-programban. A modulokban lévő kód csoportosításával együtt tarthatja a kapcsolódó kódot, és elkerülheti a névütközéseket a programban.
Syntax
// Top-level module declaration.
module [accessibility-modifier] [qualified-namespace.]module-name
declarations
// Local module declaration.
module [accessibility-modifier] module-name =
declarations
Megjegyzések
Az F#-modul olyan F#-kódszerkezetek csoportosítása, mint például a típusok, értékek, függvényértékek és kötésekben lévő do kód. Általános nyelvi futtatókörnyezeti (CLR) osztályként van implementálva, amelynek csak statikus tagjai vannak. A moduldeklarációknak két típusa van, attól függően, hogy a teljes fájl szerepel-e a modulban: egy legfelső szintű moduldeklaráció és egy helyi moduldeklaráció. A legfelső szintű moduldeklaráció tartalmazza a modul teljes fájljának tartalmát. A legfelső szintű moduldeklaráció csak a fájl első deklarációjaként jelenhet meg.
A legfelső szintű moduldeklaráció szintaxisában az opcionális minősített névtér a modult tartalmazó beágyazott névtérnevek sorozata. A minősített névteret korábban nem kell deklarálni.
Nem kell behúznia a deklarációkat egy legfelső szintű modulban. Minden deklarációt be kell húznia a helyi modulokba. Egy helyi moduldeklarációban csak a modul deklarációja alatt behúzott deklarációk részei a modulnak.
Ha egy kódfájl nem legfelső szintű moduldeklarációval vagy névtérdeklarációval kezdődik, a fájl teljes tartalma, beleértve a helyi modulokat is, egy implicit módon létrehozott legfelső szintű modul részévé válik, amelynek neve megegyezik a fájl nevével, a kiterjesztés nélkül, az első betű nagybetűssé alakítva. Vegyük például az alábbi fájlt.
// In the file program.fs.
let x = 40
Ez a fájl úgy lesz lefordítva, mintha az így lett volna megírva:
module Program
let x = 40
Ha egy fájlban több modul is található, minden modulhoz helyi moduldeklarációt kell használnia. Ha egy beágyazó névteret deklarál, ezek a modulok a beágyazó névtér részét képezik. Ha a rendszer nem deklarál egy burkoló névteret, a modulok az implicit módon létrehozott legfelső szintű modul részévé válnak. Az alábbi példakód egy több modult tartalmazó kódfájlt mutat be. A fordító implicit módon létrehoz egy legfelső szintű modult, amely MyModule1MyModule2 a Multiplemoduleslegfelső szintű modulba van ágyazva.
// In the file multiplemodules.fs.
// MyModule1
module MyModule1 =
// Indent all program elements within modules that are declared with an equal sign.
let module1Value = 100
let module1Function x =
x + 10
// MyModule2
module MyModule2 =
let module2Value = 121
// Use a qualified name to access the function.
// from MyModule1.
let module2Function x =
x * (MyModule1.module1Function module2Value)
Ha több fájllal rendelkezik egy projektben vagy egy fordításban, vagy ha tárat készít, a fájl tetején egy névtérdeklarációt vagy moduldeklarációt kell tartalmaznia. Az F# fordító csak akkor határozza meg implicit módon a modul nevét, ha egy projektben vagy fordítási parancssorban csak egy fájl található, és ön egy alkalmazást hoz létre.
Az akadálymentesség-módosító a következők egyike lehet: public, private, internal. Ezzel kapcsolatos további információt a Hozzáférés-vezérléscímű témakörben talál. Az alapértelmezett érték nyilvános.
Hivatkozási kód modulokban
Ha egy másik modul függvényeire, típusaira és értékeire hivatkozik, minősített nevet kell használnia, vagy meg kell nyitnia a modult. Minősített név használata esetén meg kell adnia a kívánt programelem névtereit, moduljait és azonosítóit. A minősített elérési út egyes részeit ponttal (.) kell elválasztani az alábbiak szerint.
Namespace1.Namespace2.ModuleName.Identifier
A kód egyszerűsítése érdekében megnyithatja a modult vagy egy vagy több névteret. További információ a névterek és modulok megnyitásáról: Import Deklarációk: A open kulcsszó.
Az alábbi példakód egy legfelső szintű modult mutat be, amely a fájl végéig tartalmazza az összes kódot.
module Arithmetic
let add x y =
x + y
let sub x y =
x - y
Ha ezt a kódot egy másik fájlból szeretné használni ugyanabban a projektben, akkor vagy minősített neveket használ, vagy a függvények használata előtt megnyitja a modult, ahogy az alábbi példákban is látható.
// Fully qualify the function name.
let result1 = Arithmetic.add 5 9
// Open the module.
open Arithmetic
let result2 = add 5 9
Beágyazott modulok
A modulok beágyazhatók. A belső modulokat a külső moduldeklarációkig be kell húzni, hogy jelezzék, hogy belső modulok, nem pedig új modulok. Hasonlítsa össze például a következő két példát. A modul Z egy belső modul az alábbi kódban.
module Y =
let x = 1
module Z =
let z = 5
A modul Z azonban a következő kódban szereplő modul Y testvére.
module Y =
let x = 1
module Z =
let z = 5
A modul Z a következő kód testvérmodulja is, mivel a modul Ymás deklarációihoz képest nincs behúzva.
module Y =
let x = 1
module Z =
let z = 5
Végül, ha a külső modul nem rendelkezik deklarációkkal, és azonnal egy másik moduldeklaráció követi, az új moduldeklaráció belső modulnak minősül, de a fordító figyelmezteti, ha a második moduldefiníció nincs az elsőnél távolabb behúzva.
// This code produces a warning, but treats Z as a inner module.
module Y =
module Z =
let z = 5
A figyelmeztetés eltávolításához behúzhatja a belső modult.
module Y =
module Z =
let z = 5
Ha azt szeretné, hogy egy fájl összes kódja egyetlen külső modulban legyen, és belső modulokat szeretne, a külső modulhoz nem szükséges az egyenlőségjel, és a külső modulban lévő deklarációkat, beleértve a belső modul deklarációit, nem kell behúzni. A belső modul deklarációiban lévő deklarációkat be kell húzni. Az alábbi kód ezt az esetet mutatja be.
// The top-level module declaration can be omitted if the file is named
// TopLevel.fs or topLevel.fs, and the file is the only file in an
// application.
module TopLevel
let topLevelX = 5
module Inner1 =
let inner1X = 1
module Inner2 =
let inner2X = 5
Rekurzív modulok
Az F# 4.1 bemutatja a modulok fogalmát, amelyek lehetővé teszik, hogy minden tartalmazott kód kölcsönösen rekurzív legyen. Ez a művelet a . használatával module rectörténik. module rec A használat enyhítheti néhány fájdalmat, ha nem tud kölcsönösen hivatkozó kódot írni a típusok és modulok között. Az alábbiakban egy példa látható erre:
module rec RecursiveModule =
type Orientation = Up | Down
type PeelState = Peeled | Unpeeled
// This exception depends on the type below.
exception DontSqueezeTheBananaException of Banana
type Banana(orientation : Orientation) =
member val IsPeeled = false with get, set
member val Orientation = orientation with get, set
member val Sides: PeelState list = [ Unpeeled; Unpeeled; Unpeeled; Unpeeled] with get, set
member self.Peel() = BananaHelpers.peel self // Note the dependency on the BananaHelpers module.
member self.SqueezeJuiceOut() = raise (DontSqueezeTheBananaException self) // This member depends on the exception above.
module BananaHelpers =
let peel (b: Banana) =
let flip (banana: Banana) =
match banana.Orientation with
| Up ->
banana.Orientation <- Down
banana
| Down -> banana
let peelSides (banana: Banana) =
banana.Sides
|> List.map (function
| Unpeeled -> Peeled
| Peeled -> Peeled)
match b.Orientation with
| Up -> b |> flip |> peelSides
| Down -> b |> peelSides
Vegye figyelembe, hogy a kivétel DontSqueezeTheBananaException és az osztály Banana egyaránt egymásra hivatkozik. Emellett a modul BananaHelpers és az osztály Banana is hivatkozik egymásra. Ez nem fejezhető ki F# nyelven, ha eltávolította a kulcsszót rec a RecursiveModule modulból.
Ez a képesség az F# 4.1 névterekben is lehetséges.
