Lexikai zárványok

A lezárások hívhatóak, amelyek változókat rögzítenek az elzáródó környezetből. A függvény- és műveletlezárások is létrehozhatók. Egy művelet bezárása létrehozható egy függvényen belül, de csak egy műveletben alkalmazható.

Q# két mechanizmusa van a lezárások létrehozására: lambda kifejezések és részleges alkalmazás.

Lambda-kifejezések

A lambda kifejezés létrehoz egy névtelen függvényt vagy műveletet. Az alapszintaxis a paraméterek kötésére szolgáló szimbólumrekord, egy nyíl (-> egy függvényhez és => egy művelethez), valamint egy kifejezés, amelyet az alkalmazáskor ki kell értékelni.

// Function that captures 'x':
y -> x + y

// Operation that captures 'qubit':
deg => Rx(deg * PI() / 180.0, qubit)

// Function that captures nothing:
(x, y) -> x + y

Paraméterek

A paraméterek a változódeklarációs utasítás bal oldalán található szimbólumok használatával vannak megkötve. A paraméterrekord típusa implicit. A típusjegyzetek nem támogatottak; Ha a típuskövetkeztetés sikertelen, előfordulhat, hogy létre kell hoznia egy legfelső szintű hívható deklarációt, és részleges alkalmazást kell használnia.

Mutable capture változók

A változók nem rögzíthetők. Ha csak a lambda kifejezés létrehozásakor kell rögzítenie egy változó értékét, létrehozhat egy nem módosítható másolatot:

// ERROR: 'variable' cannot be captured.
mutable variable = 1;
let f = () -> variable;

// OK.
let value = variable;
let g = () -> value;

Jellemzők

A névtelen műveletek jellemzői a lambda alkalmazásai alapján következtetnek. Ha a lambdát funktoralkalmazással használják, vagy olyan környezetben, amely jellemzőre számít, a lambda ezt a tulajdonságot feltételezi. Például:

operation NoOp(q : Qubit) : Unit is Adj {}
operation Main() : Unit {
    use q = Qubit();
    let foo = () => NoOp(q);
    foo(); // Has type Unit => Unit with no characteristics

    let bar = () => NoOp(q);
    Adjoint bar(); // Has type Unit => Unit is Adj
}

Ha a lambda művelethez a kikövetkeztetettnél eltérő jellemzőkre van szüksége, akkor ehelyett létre kell hoznia egy legfelső szintű műveleti deklarációt.

Részleges alkalmazás

A részleges alkalmazás kényelmes rövidítés a hívható argumentumainak egy részének, de nem mindegyikének alkalmazásához. A szintaxis megegyezik a híváskifejezéssel, de a nem jóváhagyott argumentumok helyébe a _következő lép: . Elméletileg a részleges alkalmazás egyenértékű egy lambda kifejezéssel, amely rögzíti az alkalmazott argumentumokat, és paraméterekként veszi fel a nem jóváhagyott argumentumokat.

Ha például f ez egy függvény és o egy művelet, a rögzített változó x nem módosítható:

Részleges alkalmazás	Lambda kifejezés
f(x, _)	a -> f(x, a)
o(x, _)	a => o(x, a)
f(_, (1, _))	(a, b) -> f(a, (1, b))[^1]
f((_, _, x), (1, _))	((a, b), c) -> f((a, b, x), (1, c))

Mutable capture változók

A lambda kifejezésektől eltérően a részleges alkalmazás automatikusan rögzítheti egy mutable változó értékének másolatát:

mutable variable = 1;
let f = Foo(variable, _);

Ez egyenértékű a következő lambda kifejezéssel:

mutable variable = 1;
let value = variable;
let f = x -> Foo(value, x);

---

[^1]: A rekord paraméter szigorúan meg van írva (a, (b)), de (b) egyenértékű a paraméterrel b.