Fechamentos

Os fechamentos são callables que capturam variáveis do ambiente delimitamento. Os fechamentos de função e de operação podem ser criados. 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 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 está implícito. Não há suporte para anotações de tipo; se a inferência de tipo falhar, talvez seja necessário criar uma declaração callable de nível superior e usar um aplicativo parcial.

Variáveis de captura mutáveis

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, você poderá criar 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 nas aplicações do lambda. Se o lambda for usado com um aplicativo functor ou em um contexto que espere 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 a inferida, será necessário criar uma declaração de operação de nível superior.

Aplicativo parcial

A aplicação parcial é uma abreviação conveniente para aplicar alguns, mas não todos, dos argumentos de um callable. A sintaxe é a mesma que uma expressão de chamada, mas argumentos não aplicados são substituídos por _. Conceitualmente, o aplicativo 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 e o é uma operação e a variável capturada x é imutável:

Variáveis de captura mutáveis

Ao contrário das expressões lambda, o aplicativo 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 é estritamente gravada (a, (b)), mas (b) é equivalente a b.