Controle de fluxo

Avance em um fluxo contínuo de decisões que devem ser tomadas.

Fallback

As operações padrão ou de coalescência nula são definidas com dois pontos de interrogação ?? e funcionam da seguinte maneira:

<expressãoTalvezNulaOuFalha> ?? <valorFallback>

Caso o lado esquerdo não seja null nem Error, então ele é usado; caso contrário, o valor de fallback é retornado.

de forma semelhante, você pode usar o operador de atribuição por coalescência nula ??=

If

Declarações If são definidas com um ponto de interrogação ?, como abaixo:

<condição> ? <resposta>

como não há alternativa, null é retornado se a condição não for atendida

If-Else

Declarações If-Else são definidas com um ponto de interrogação ? seguido de dois pontos :, como abaixo:

<condição> ? <resposta> : <alternativa>

Para usar declarações If-Else multilinhas, envolva a resposta em chaves {...} assim:

<condição> ? {
  <resposta>
} : {
  <alternativa>
}

Cases

Cases são definidos com a seta espessa => e são automaticamente encadeados, criando uma sintaxe intuitiva e simplificada, semelhante a uma declaração switch, sem a possibilidade de queda. Isso permite que condições não relacionadas sejam misturadas, resultando em uma estrutura if-else-if-else mais concisa:

<condição1> => <respostaPara1>
<condição2> => <respostaPara2>
<condição3> => <respostaPara3>
...

Exemplo:

escolha = (x) -> {
  x == 1 => 'a'
  x == 2 => 'b'
  x == 3 => 'c'
}

escolha(2)  # 'b'
escolha(8)  # null

Para fornecer um valor padrão para seu método, você pode adicionar um caso pega-tudo usando um sublinhado _ no final da sequência:

escolha = (x) -> {
  x == 1 => 'a'
  x == 2 => 'b'
  x == 3 => 'c'
  _      => 'd'
}

escolha(2)  # 'b'
escolha(8)  # 'd'

Para cenários mais complexos, você pode usar blocos como resultados para cada caso:

...
  condição => {
    # faça algo
    'foo'
  }
  _ => {
    # faça outra coisa
    'bar'
  }
...

Cases devem terminar em um caso pega-tudo _ ou final do bloco. O uso mais efetivo de Cases é dentro de métodos na parte inferior do corpo do método.

Embora seja possível adicionar Cases aninhados, é melhor evitar construções excessivamente complexas. Isso torna o código mais difícil de seguir e provavelmente perde o objetivo de usar esse recurso.

Pode ser mais apropriado extrair essa lógica para um método separado. O FatScript incentiva os desenvolvedores a dividir a lógica em métodos distintos, ajudando a evitar código spaghetti.

Switch

O operador Switch é denotado pelo símbolo >>, que guia o fluxo de controle baseado na correspondência do valor com uma série de casos:

Sintaxe:

<valor> >> {
  <valorCaso1> => <respostaPara1>
  <valorCaso2> => <respostaPara2>
  ...
  _ => <respostaPadrão>
}

Cada caso no bloco Switch é avaliado em ordem até que uma correspondência seja encontrada e o resultado do caso correspondente é retornado:

escolher = -> _ >> {
  1 => 'um'
  2 => 'dois'
  3 => 'três'
  _ => 'outro'
}

escolher(2)  # 'dois'
escolher(4)  # 'outro'

Os casos do Switch também podem envolver expressões, permitindo correspondências dinâmicas:

avaliar = (x, y) -> x >> {
  y + 1 => 'logo acima de y'
  y - 1 => 'logo abaixo de y'
  _     => 'não diretamente ao redor de y'
}

avaliar(5, 4)  # 'logo acima de y'
avaliar(3, 4)  # 'logo abaixo de y'
avaliar(7, 4)  # 'não diretamente ao redor de y'