Diretrizes de formatação (F#) de código.
Este tópico resume as diretrizes de recuo do código para F#. Como o idioma F# não é sensível à quebras de linha e recuo, não é apenas uma questão de legibilidade, um problema estético ou um problema de padronização de codificação para formatar corretamente o seu código. Você deve formatar seu código corretamente compilar corretamente.
Regras gerais do recuo
Quando é necessário o recuo, você deve usar espaços, não tabulações. É necessário pelo menos um espaço. Sua organização pode criar padrões de codificação para especificar o número de espaços para usar o recuo; espaços de três ou quatro de recuo em cada nível onde ocorre o recuo é normal. Você pode configurar Visual Studio para corresponder aos padrões de recuo de sua organização, alterando as opções na Opções caixa de diálogo, está disponível a partir de Ferramentas menu. No O Editor de texto nó, expanda F# e, em seguida, clique em guias. Para obter uma descrição das opções disponíveis, consulte Guias, todos os idiomas, o Editor de texto, caixa de diálogo Opções.
Em geral, quando o compilador analisa seu código, ele mantém uma pilha interna que indica o nível atual de aninhamento. Quando o código é recuado, um novo nível de aninhamento é criado ou colocado nesta pilha interna. Quando uma construção termina, o nível é exibido. Recuo é uma maneira de sinalizar o final de um nível e a pilha interna de pop, mas certos símbolos também fazer com que o nível para ser exibido, como o end palavra-chave, ou uma chave de fechamento ou parênteses.
Código em uma construção de várias linhas, como, por exemplo, uma definição de tipo de definição de função try...with Construir e o loop construções, deve ser recuado em relação à linha de abertura da construção. A primeira linha recuada estabelece uma posição de coluna código subseqüente na mesma construção. O nível de recuo é chamado um contexto. A posição da coluna define uma coluna mínima, conhecida como um linha offside, para as linhas subseqüentes do código que estão no mesmo contexto. Quando uma linha de código é encontrada recuado a menos que a posição de coluna estabelecida, o compilador pressupõe que o contexto foi finalizada e que está agora codificando no próximo nível, no contexto anterior. O termo offside é usado para descrever as condições em que uma linha de código aciona o final de uma construção porque não é recuada suficiente. Em outras palavras, o código para a esquerda de uma linha de offside é offside. No código recuado corretamente, você pode tirar proveito da regra offside para delinear final das construções. Se você usar incorretamente o recuo, uma condição de offside pode fazer com que o compilador emitir um aviso ou pode ocasionar a interpretação incorreta do seu código.
Linhas offside são determinadas da seguinte maneira.
Um = símbolo associado a uma let apresenta uma linha de offside a coluna do primeiro símbolo após o = sinal.
Em um if...then...else expressão, a posição da coluna do primeiro símbolo após o then palavra-chave ou o else palavra-chave introduz uma linha de offside.
Em um try...with expressão, o primeiro símbolo após try apresenta uma linha de offside.
Em um match expressão, o primeiro símbolo após with e o primeiro símbolo após cada -> apresentar offside linhas.
O primeiro símbolo após with em um tipo de extensão apresenta uma linha de offside.
O primeiro símbolo após uma chave de abertura ou um parêntese ou após a begin palavra-chave, apresenta uma linha de offside.
O primeiro caractere em palavras-chave let, if, e module apresentar offside linhas.
Os exemplos de código a seguir ilustram as regras de recuo. Aqui, as instruções de impressão dependem de recuo para associar o contexto apropriado. Toda vez que o recuo é deslocado, o contexto é exibido e retorna ao contexto anterior. Portanto, um espaço é impressa no final de cada iteração; "Concluído"! só é impressa uma vez porque o recuo offside estabelece que não é parte do loop. A impressão da seqüência de caracteres "Contexto de nível superior" não é parte da função. Portanto, ele é impresso em primeiro lugar, durante a inicialização estática, antes que a função é chamada.
let printList list1 =
for elem in list1 do
if elem > 0 then
printf "%d" elem
elif elem = 0 then
printf "Zero"
else
printf "(Negative number)"
printf " "
printfn "Done!"
printfn "Top-level context."
printList [-1;0;1;2;3]
A saída é da seguinte maneira.
Top-level context
(Negative number) Zero 1 2 3 Done!
Ao quebrar linhas longas, a continuação da linha deve ser recuada mais longe do que a construção de delimitador. Por exemplo, os argumentos de função devem ser recuados mais longe do que o primeiro caractere do nome da função, conforme mostrado no código a seguir.
let myFunction1 a b = a + b
let myFunction2(a, b) = a + b
let someFunction param1 param2 =
let result = myFunction1 param1
param2
result * 100
let someOtherFunction param1 param2 =
let result = myFunction2(param1,
param2)
result * 100
Há exceções a essas regras, conforme descrito na próxima seção.
Recuo em módulos
Código em um módulo local deve ser recuado em relação ao módulo, mas não tem o código em um módulo de nível superior será recuado. Elementos de espaço para nome não possuem ser recuado.
Os exemplos de código a seguir ilustram esse processo.
// Program1.fs
// A is a top-level module.
module A
let function1 a b = a - b * b
// Program2.fs
// A1 and A2 are local modules.
module A1 =
let function1 a b = a*a + b*b
module A2 =
let function2 a b = a*a - b*b
Para obter mais informações, consulte Módulos (F#).
Exceções às regras básicas de recuo
A regra geral, conforme descrito na seção anterior, é que o código em construções de várias linhas deve ser recuado em relação ao recuo da primeira linha da construção e que o final da construção é determinado pelo quando ocorre a primeira linha offside. Uma exceção à regra sobre quando o final de contextos é que algumas construções, como o try...with a expressão, o if...then...else expressão e o uso de and sintaxe para declarar mutuamente recursivas: funções ou tipos, tem várias partes. Recuar as partes posteriores, como then e else em um if...then...else a expressão, ao mesmo nível como o token que inicia a expressão, mas em vez de indicando um fim ao contexto, representa a próxima parte do mesmo contexto. Portanto, um if...then...else expressão pode ser escrito como no seguinte exemplo de código.
let abs1 x =
if (x >= 0)
then
x
else
-x
A exceção à regra offside só é aplicável a then e else palavras-chave. Portanto, embora não seja um erro para recuar a then e else ainda mais, falhando recuar as linhas de código em um then bloco produz um aviso. Isso é ilustrado em linhas de código a seguir.
// The following code does not produce a warning.
let abs2 x =
if (x >= 0)
then
x
else
-x
// The following code is not indented properly and produces a warning.
let abs3 x =
if (x >= 0)
then
x
else
-x
Para o código em um else aplica-se do bloco, uma regra especial adicional. O aviso no exemplo anterior ocorre somente no código na then bloco, não no código na else bloco. Isso permite que você escreva código que verifica várias condições, no início de uma função sem forçar o resto do código para a função, que pode estar em um else bloco, para ser recuado. Assim, você pode escrever o seguinte sem produzir um aviso.
let abs4 x =
if (x >= 0) then x else
-x
Outra exceção à regra que contextos terminam quando uma linha não é recuada, desde uma linha anterior é para operadores fixos, como + e |>. Linhas que começam com operadores fixos são permitidas para começar a (1 + oplength) colunas antes da posição normal sem disparar uma extremidade de contexto, onde oplength é o número de caracteres que compõem o operador. Isso faz com que o primeiro símbolo depois do operador para alinhar com a linha anterior.
Por exemplo, no código a seguir, o + símbolo é permitido a ser recuadas duas colunas menor que a linha anterior.
let function1 arg1 arg2 arg3 arg4 =
arg1 + arg2
+ arg3 + arg4
Embora o recuo normalmente aumenta conforme o nível de aninhamento se torna maior, há várias construções em que o compilador permite que você redefina o recuo para uma posição inferior da coluna.
As construções que permitem uma redefinição da posição da coluna são as seguintes:
Corpos de funções anônimas. No código a seguir, a expressão a impressão começa em uma posição de coluna que está bem à esquerda que o fun palavra-chave. No entanto, a linha não deve iniciar em uma coluna à esquerda do início do nível de recuo anterior (ou seja, à esquerda da L na List).
let printListWithOffset a list1 = List.iter (fun elem -> printfn "%d" (a + elem)) list1Construções entre parênteses ou por begin e end em um then ou else bloquear uma if...then...else fornecido de expressão, o recuo é não menos do que a posição de coluna a if palavra-chave. Essa exceção permite um estilo de codificação na qual um parêntese de abertura ou begin é usado no final de uma linha após then ou else.
Corpos dos módulos, classes, interfaces e estruturas delimitadas por begin...end, {...}, class...end, ou interface...end. Isso permite que um estilo a palavra-chave de abertura de uma definição de tipo pode ser na mesma linha como o nome de tipo sem forçar o corpo inteiro será recuado mais longe do que a palavra-chave de abertura.
type IMyInterface = interface abstract Function1: int -> int end