permitir que as ligações (F#)
A ligação associa um identificador com um valor ou uma função.Você pode usar o let palavra-chave para vincular a um nome de um valor ou 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 é usado em expressões para definir valores ou função para um ou mais nomes de vinculação.A forma mais simples de let expressão vincula um nome para um valor simple, como segue.
let i = 1
Se separar a expressão a partir do identificador por meio de uma nova linha, você deve recuar cada linha de 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 a linha até exatamente com o primeiro caractere do let palavra-chave:
let result =
let i, j, k = (1, 2, 3)
// Body expression:
i + 2*j + 3*k
A let ligação pode aparecer no nível de módulo na definição de um tipo de classe ou em locais escopos, 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.Nomes vinculados são utilizáveis depois do ponto de definição, mas não em qualquer ponto antes do let vinculação aparece, como 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 seguem 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 um padrão de tupla:
let function2 (a, b) = a + b
A let avalia a expressão de vinculação ao valor da última expressão.Portanto, no seguinte exemplo de código, o valor de result é calculado de 100 * function3 (1, 2), que é avaliado como 300.
let result =
let function3 (a, b) = a + b
100 * function3 (1, 2)
Para mais informações, consulte Funções (F#).
Anotações de tipo
Você pode especificar os tipos de parâmetros, incluindo dois-pontos (:) seguido por um nome de tipo, tudo entre parênteses.Você também pode especificar o tipo de valor de retorno, acrescentando dois pontos e tipo após o último parâmetro.As anotações de tipo completo para function1, com números inteiros como tipos de parâmetro, seria o seguinte.
let function1 (a: int) : int = a + 1
Quando não há nenhum parâmetro de tipo explícito, inferência de tipo é usada para determinar os tipos de parâmetros de funções.Isso pode incluir automaticamente generalizar o tipo de parâmetro para ser genérico.
Para obter mais informações, consulte Generalização automática (F#) e Inferência de tipo (F#).
permitem ligações em Classes
A let ligação pode aparecer em um tipo de classe, mas não em uma estrutura ou um tipo de registro.Para usar um permitem um tipo de classe de ligação, a classe deve ter um construtor principal.Parâmetros do construtor devem aparecer após o nome de tipo na definição de classe.A let ligação em um tipo de classe define campos particulares e membros para esse tipo de classe e, juntamente com do o código para o construtor primário para o tipo de ligações no tipo de formulários.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 são limitados para o tipo no qual elas são declaradas.Para obter mais informações, consulte permitir que as ligações em Classes (F#) e Classes (F#).
Parâmetros de tipo em permitem ligações
A let vinculação no nível de módulo, em um tipo ou uma expressão de cálculo pode ter parâmetros de tipo explícito.Um let binding em uma expressão, como dentro de uma definição de função não pode ter parâmetros de tipo.Para 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 mostrado no código a seguir.
[<Obsolete>]
let function1 x y = x + y
Escopo e a acessibilidade de ligações permitem
O escopo de uma entidade declarado com uma associação let é limitado a parte a que contém o escopo (como uma função, módulo, arquivo ou classe) após a vinculação aparece.Portanto, pode-se dizer que uma associação let apresenta um nome em um escopo.Em um módulo, uma função ou um valor de limite permitem é acessível para clientes de um módulo como o módulo é acessível, pois as ligações permitem que um módulo são compiladas em funções públicas do módulo.Por outro lado, permitem que as ligações em uma classe são particulares à classe.
Normalmente, as funções em módulos devem ser qualificadas pelo nome do módulo quando usado pelo código do cliente.Por exemplo, se um módulo de Module1 tem uma função function1, especificam os usuários Module1.function1 para referir-se a função.
Os usuários de um módulo podem usar uma declaração de importação para disponibilizar as funções dentro desse módulo para uso sem ser qualificado pelo nome do módulo.No exemplo que acabamos de mencionar, os usuários do módulo nesse caso abra o módulo usando Importar declaração abrir Module1 e depois consulte function1 diretamente.
module Module1 =
let function1 x = x + 1.0
module Module2 =
let function2 x =
Module1.function1 x
open Module1
let function3 x =
function1 x
Alguns módulos têm o atributo RequireQualifiedAccess, que significa que as funções que elas expõem devem ser qualificadas com o nome do módulo.Por exemplo, o módulo de F# lista tem esse atributo.
Para obter mais informações sobre módulos e controle de acesso, consulte Módulos (F#) e Controle de acesso (F#).