Diretrizes de formatação (F#) de código.
Este tópico resume as diretrizes de recuo de código para F#.Como o idioma F# é sensível à quebras de linha e recuo, não é apenas um problema de legibilidade, problema estético ou problema de padronização de codificação para formatar corretamente o seu código.Você deve formatar seu código corretamente para que ele seja compilado corretamente.
Regras gerais para fins de recuo
Quando é necessário o recuo, você deve usar espaços, tabulações não.É 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; três ou quatro espaços 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 que está disponível a partir do Ferramentas menu.No Editor de texto nó, expanda F# e, em seguida, clique em guias. Para obter uma descrição das opções disponíveis, consulte Opções, Editor de texto, todos os idiomas, guias.
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 para sinalizar o final de um nível e a pilha interna do 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 um parêntese.
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 construção, construções de looping, devem ser recuados em relação à linha de abertura da construção.A primeira linha recuada estabelece uma posição de coluna para o código subseqüente na construção do mesma.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 para cima, 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 o recuo incorretamente, uma condição de offside pode fazer com que o compilador para 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 depois de 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 nas 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 associá-los a 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!" é impresso apenas 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 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 a primeira linha de offside ocorre.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 últimas partes, como then e else em um if...then...else a expressão, ao mesmo nível como o símbolo que inicia a expressão, mas em vez de indicar um fim ao contexto, representa a próxima parte do mesmo contexto.Portanto, um if...then...else expressão pode ser escrito como no exemplo de código a seguir.
let abs1 x =
if (x >= 0)
then
x
else
-x
A exceção à regra offside só é aplicável a then e else as 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 |>.As 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 constituem 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 está autorizado a ser recuadas duas colunas menor do que a linha anterior.
let function1 arg1 arg2 arg3 arg4 =
arg1 + arg2
+ arg3 + arg4
Embora o recuo geralmente aumenta à medida que o nível de aninhamento fica 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 de um 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 a 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 um estilo no qual a palavra-chave de abertura de uma definição de tipo pode ser na mesma linha como o nome do 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