Deixe as ligações (F#)

A ligação associa um identificador um valor ou uma função. Você pode usar o let palavra-chave para vincular a um nome de um valor ou uma função.

// Binding a value:
let identifier-or-pattern [: type] =
   expression
body-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =
   expression
body-expression

Comentários

O let palavra-chave é usada na ligação de expressões para definir os valores ou valores de função para um ou mais nomes. A forma mais simples de let expressão vincula um nome para um valor simple, como segue:

let i = 1

Se você separar a expressão a partir do identificador usando uma linha nova, você deve recuar cada linha da expressão, como no código a seguir.

let someVeryLongIdentifier =
    // Note indentation below.
    3 * 4 + 5 * 6

Em vez de apenas um nome, um padrão de nomes pode ser especificado, por exemplo, uma tupla, conforme mostrado no código a seguir.

let i, j, k = (1, 2, 3)

O body-expression é a expressão na qual os nomes são usados. A expressão do corpo aparece em sua própria linha, recuada para a linha até exatamente com o primeiro caractere da let palavra-chave:

let result =
    let i, j, k = (1, 2, 3)
    // Body expression: 
    i + 2*j + 3*k

A let vinculação pode aparecer no nível de módulo, na definição de um tipo de classe, ou em escopos locais, como em uma definição de função. A let vinculação no nível em um módulo ou em um tipo de classe superior, não precisa ter uma expressão do corpo, mas em outros níveis de escopo, a expressão do corpo é necessária. Os nomes de limite são utilizáveis após o ponto de definição, mas não em qualquer ponto antes do let vinculação for exibida, conforme ilustrado no código a seguir.

// Error:
printfn "%d" x  
let x = 100
// OK: 
printfn "%d" x

Vinculações de função

Vinculações de função siga as regras para ligações de valor, exceto que as vinculações de função incluem o nome da função e os parâmetros, conforme mostrado no código a seguir.

let function1 a =
    a + 1

Em geral, os parâmetros são padrões, como, por exemplo, um padrão de tupla:

let function2 (a, b) = a + b

A let avalia a expressão de vinculação para o valor da última expressão. Portanto, no seguinte exemplo de código, o valor de result é calculado a partir de 100 * function3 (1, 2), que é avaliado como 300.

let result =
    let function3 (a, b) = a + b
    100 * function3 (1, 2)

Anotações de tipo

Você pode especificar os tipos de parâmetros, incluindo os dois-pontos (:) seguido de um nome de tipo entre todos os parênteses. Você também pode especificar o tipo de valor de retorno, anexando o dois-pontos e o tipo após o último parâmetro. As anotações de tipo completo para function1, com números inteiros, como os tipos de parâmetro, seria como segue:

let function1 (a: int) : int = a + 1

Quando não há nenhum parâmetro de tipo explícito, a inferência de tipo é usada para determinar os tipos de parâmetros de funções. Isso pode incluir automaticamente generalizar o tipo de um parâmetro a ser genérico.

Para obter mais informações, consulte Generalização automática (F#) e Inferência de tipo (F#).

Deixe as ligações de Classes

A let ligação pode aparecer em um tipo de classe, mas não em um tipo de estrutura ou o registro. Para usar um permitem que um tipo de classe de ligação, a classe deve ter um construtor primário. Parâmetros do construtor devem aparecer após o nome do tipo na definição de classe. A let vinculação de um tipo de classe define os campos particulares e os membros desse tipo de classe e, juntamente com do ligações no tipo de formulários o código para o construtor primário para o tipo. Os exemplos de código a seguir mostram uma classe MyClass com campos private field1 e field2.

type MyClass(a) =
    let field1 = a
    let field2 = "text"
    do printfn "%d %s" field1 field2
    member this.F input =
        printfn "Field1 %d Field2 %s Input %A" field1 field2 input

Os escopos de field1 e field2 limitam-se ao tipo no qual elas são declaradas. Para obter mais informações, consulte Deixe as ligações de Classes (F#).

Parâmetros de tipo no permitem ligações

A let vinculação no nível de módulo em um tipo, ou em uma expressão de cálculo pode ter parâmetros de tipo explícito. Um let vinculação em uma expressão, como em uma definição de função não pode ter parâmetros de tipo. Para obter mais informações, consulte Genéricos (F#).

Atributos permitem ligações

Atributos podem ser aplicados ao nível superior let ligações em um módulo, como mostra o código a seguir.

[<Obsolete>]
let function1 x y = x + y

Consulte também

Referência

Funções (F#)

Deixe as ligações de Classes (F#)