Associações let
Uma associação liga um identificador a um valor ou função. Use a palavra-chave let para associar um nome a um valor ou função.
Sintaxe
// Binding a value:
let identifier-or-pattern [: type] =expressionbody-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =expressionbody-expression
Comentários
A palavra-chave let é usada em expressões de associação para definir valores ou valores de função de um ou mais nomes. A forma mais simples da expressão let associa um nome a um valor simples, como mostrado a seguir.
let i = 1
Se você separar a expressão do identificador usando uma nova linha, deverá 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 que contenha nomes pode ser especificado. Por exemplo, uma tupla, conforme mostrado no código a seguir.
let i, j, k = (1, 2, 3)
A expressão body é a expressão na qual os nomes são usados. A expressão body aparece na própria linha, recuada para se alinhar exatamente com o primeiro caractere da palavra-chave let:
let result =
let i, j, k = (1, 2, 3)
// Body expression:
i + 2 * j + 3 * k
Uma associação let pode aparecer no nível do módulo, na definição de um tipo de classe ou em escopos locais, como em uma definição de função. Uma associação let no nível superior em um módulo ou em um tipo de classe não precisa ter uma expressão body. Mas, em outros níveis de escopo, a expressão body é necessária. Os nomes associados podem ser usados após o ponto de definição, mas não antes de a associação let ser exibida, como ilustrado no código a seguir.
// Error:
printfn "%d" x
let x = 100
// OK:
printfn "%d" x
Associações de função
As associações de função seguem as regras das associações de valor. A exceção é que as associaçõ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
Uma expressão de associação let é avaliada como o valor da última expressão. Portanto, no exemplo de código a seguir, o valor de result é computado de 100 * function3 (1, 2), que é avaliado como 300.
let result =
let function3 (a, b) = a + b
100 * function3 (1, 2)
Para obter mais informações, consulte Funções.
Anotações de tipo
Você pode especificar tipos para parâmetros incluindo dois-pontos (:) seguido de um nome de tipo, tudo entre parênteses. Também pode especificar o tipo do valor retornado acrescentando os dois-pontos e o tipo após o último parâmetro. As anotações completas de tipo de function1, com inteiros como tipos de parâmetro, seriam como no exemplo a seguir.
let function1 (a: int) : int = a + 1
Quando não há parâmetros de tipo explícitos, a inferência de tipos é usada para determinar os tipos de parâmetro das funções. Isso pode incluir a generalização automática do tipo de um parâmetro como genérico.
Para saber mais, confira Generalização automática e Inferência de tipos.
Associações let em classes
Uma associação let pode aparecer em um tipo de classe, mas não em uma estrutura ou tipo de registro. Para usar uma associação let em um tipo de classe, a classe deve ter um construtor primário. Os parâmetros do construtor devem aparecer após o nome do tipo na definição de classe. Uma associação let em um tipo de classe define campos privados e membros desse tipo de classe e, juntamente com associações do no tipo, forma o código do construtor primário do tipo. Os exemplos de código a seguir mostram uma classe MyClass com campos privados 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 ao tipo no qual são declarados. Para obter mais informações, confira Associações let em classes e Classes.
Parâmetros de tipo em associações let
Uma associação let no nível do módulo, em um tipo ou em uma expressão de computação pode ter parâmetros de tipo explícitos. Uma associação let 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.
Atributos nas associações let
Os atributos podem ser aplicados a associações let de nível superior em um módulo, conforme mostrado no código a seguir.
[<Obsolete>]
let function1 x y = x + y
Escopo e acessibilidade das associações let
O escopo de uma entidade declarada com uma associação let é limitado à parte do escopo contentor (como uma função, módulo, arquivo ou classe), após a associação ser exibida. Portanto, pode-se dizer que uma associação let introduz um nome em um escopo. Em um módulo, um valor ou função let-bound é acessível aos clientes de um módulo, desde que o módulo esteja acessível, pois as associações let em um módulo são compiladas em funções públicas do módulo. Por outro lado, associações let em uma classe são privadas para ela.
Normalmente, as funções em módulos devem ser qualificadas pelo nome do módulo quando usadas pelo código do cliente. Por exemplo, se um módulo Module1 tivesse uma função function1, os usuários especificariam Module1.function1 para fazer referência à função.
Os usuários de um módulo podem usar uma declaração de importação para disponibilizar as funções nesse módulo sem qualificação pelo nome do módulo. No exemplo mencionado, os usuários do módulo podem, nesse caso, abrir o módulo usando a declaração de importação open Module1 e, posteriormente, fazer referência diretamente a function1.
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, o que significa que as funções expostas devem ser qualificadas com o nome do módulo. Por exemplo, o módulo F# List tem esse atributo.
Para obter mais informações sobre módulos e controle de acesso, confira Módulos e Controle de acesso.
