permitir associações

Uma associação associa um identificador a um valor ou função. Use a let palavra-chave 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

Observações

A let palavra-chave é usada em expressões de associação para definir valores ou valores de função para um ou mais nomes. A forma mais simples da let expressão associa um nome a um valor simples, da seguinte maneira.

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 contém 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 corporal é a expressão na qual os nomes são usados. A expressão do corpo aparece em sua própria linha, recuada para alinhar exatamente com o primeiro caractere na let palavra-chave:

let result =

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

    // Body expression:
    i + 2 * j + 3 * k

Uma let associação 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 let associação no nível superior em um módulo ou em um tipo de classe não precisa ter uma expressão corporal, mas em outros níveis de escopo, a expressão corporal é necessária. Os nomes associados são utilizáveis após o ponto de definição, mas não em nenhum momento antes da let associação aparecer, 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 para associações de valor, exceto 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 let expressão de associação é avaliada como o valor da última expressão. Portanto, no exemplo de código a seguir, o valor é 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. Você também pode especificar o tipo do valor retornado acrescentando o dois-pontos e o tipo após o último parâmetro. As anotações completas de tipo para function1, com inteiros como os tipos de parâmetro, seriam as seguintes.

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

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

Para obter mais informações, consulte Generalização Automática e Inferência de Tipo.

permitir associações em classes

Uma let associação 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 let associação em um tipo de classe define campos e membros privados para esse tipo de classe e, juntamente com do associações no tipo, forma o código para o construtor primário para o 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, consulte let Associações em Classes e Classes.

Parâmetros de tipo em associações de let

Uma let associação 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 dentro de uma definição de função, não pode ter parâmetros de tipo. Para obter mais informações, consulte Genéricos.

Atributos em associações let

Os atributos podem ser aplicados a associações de nível let superior em um módulo, conforme mostrado no código a seguir.

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

Escopo e acessibilidade de associações let

O escopo de uma entidade declarada com uma associação let é limitado à parte do escopo que contém (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 de let-bound é acessível aos clientes de um módulo, desde que o módulo esteja acessível, uma vez que as associações de let em um módulo são compiladas em funções públicas do módulo. Por outro lado, permitir que as associações em uma classe sejam privadas para a classe.

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 tiver uma função function1, os usuários especificarão Module1.function1 se referir à 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 serem qualificados 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 open Module1 de importação e, depois disso, fazer function1 referência 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, 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, consulte Módulos e Controle de Acesso.

Consulte também

• Funções
• let Associações em classes