Fechamentos

Os fechamentos são chamáveis que capturam variáveis do ambiente de fechamento. É possível criar fechamentos de função e de operação. Um fechamento de operação pode ser criado dentro de uma função, mas só pode ser aplicado em uma operação.

Q# tem dois mecanismos para criar fechamentos: expressões lambda e aplicação parcial.

Expressões lambda

Uma expressão lambda cria uma função ou uma operação anônima. A sintaxe básica é uma tupla de símbolo para associar os parâmetros, uma seta (-> para uma função e => para uma operação) e uma expressão a ser avaliada quando aplicada.

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

Parâmetros

Os parâmetros são associados usando uma tupla de símbolo idêntica ao lado esquerdo de uma instrução de declaração de variável. O tipo da tupla de parâmetro é implícito. Não há suporte para anotações de tipo. Se a inferência de tipos falhar, poderá ser necessário criar uma declaração de chamável de nível superior e usar uma aplicação parcial.

Variáveis de captura mutáveis

As variáveis mutáveis não podem ser capturadas. Se você precisar capturar apenas o valor de uma variável mutável no instante em que a expressão lambda for criada, crie uma cópia imutável:

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

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

Características

As características de uma operação anônima são inferidas com base nos aplicativos do lambda. Se o lambda for usado com um aplicativo functor ou em um contexto que espera uma característica, o lambda será inferido para ter essa característica. Por exemplo:

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
}

Se você precisar de características diferentes para uma operação lambda do que as inferidas, será necessário criar uma declaração de operação de nível superior.

Aplicativo parcial

A aplicação parcial é uma forma mais fácil de aplicar alguns, mas não todos, os argumentos de um chamável. A sintaxe é a mesma que a de uma expressão de chamada, mas os argumentos não aplicados são substituídos por _. Conceitualmente, a aplicação parcial é equivalente a uma expressão lambda que captura os argumentos aplicados e usa os argumentos não aplicados como parâmetros.

Por exemplo, considerando que f é uma função, o é uma operação e a variável capturada x é imutável:

Aplicativo parcial	Expressão lambda
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))

Variáveis de captura mutáveis

Ao contrário das expressões lambda, a aplicação parcial pode capturar automaticamente uma cópia do valor de uma variável mutável:

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

Isso é equivalente à seguinte expressão lambda:

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

---

[^1]: a tupla do parâmetro é escrita estritamente (a, (b)), mas (b) é equivalente a b.