Entradas

As entradas são pares chave-valor que existem no escopo onde são declaradas.

Nomeação

Os nomes das entradas (chaves) não podem começar com uma letra maiúscula, que é a distinção com relação aos tipos. Os identificadores são sensíveis a maiúsculas e minúsculas, portanto "batatasfritas" e "batatasFritas" seriam considerados entradas diferentes.

A convenção recomendada é usar camelCase para as entradas.

você pode usar um nome arbitrário como chave usando nomeação dinâmica

Declaração e atribuição

Em FatScript, você pode declarar entradas simplesmente atribuindo um valor:

isOnline: Boolean = true
age: Number       = 25
name: Text        = 'João'

Os tipos também podem ser inferidos a partir da atribuição:

isOnline = true    # Boolean
age      = 25      # Number
name     = 'João'  # Text

Entradas imutáveis

Quando uma entrada é declarada em FatScript, ela é imutável por padrão. Isso significa que, uma vez que você atribui um valor a ela, não pode alterá-lo:

fruta = 'banana'
fruta = 'abacate'  # gera AssignError (erro de atribuição) porque fruta é imutável

As entradas imutáveis são úteis quando você quer garantir que um valor permaneça constante durante a execução do programa.

Exceção à regra

Vale ressaltar que a imutabilidade se aplica apenas à própria entrada, mas não ao seu conteúdo quando se trata de um escopo.

No FatScript, surge um paradoxo, já que todas as seguintes afirmações são verdadeiras:

• Uma entrada imutável não pode ser alterada depois de definida.
• Um escopo pode sempre aceitar novas entradas.
• Uma entrada pode armazenar um escopo.

Veja:

s = { a = 1, b = 2 }
s.c = 3  # mesmo que s seja imutável, ele aceita o novo valor de c
s        # agora { a = 1, b = 2, c = 3 }

isso não é um bug, é um recurso

Isso ocorre porque os escopos são passados por referência e podem sempre ser "modificados" pela adição de novas entradas, mesmo que a entrada que o contém seja imutável. Então, neste caso, é o mesmo, mas não é exatamente o mesmo.

Por outro lado, listas declaradas como imutáveis se comportam de forma mais consistente com a regra, pois novas entradas não podem ser acrescentadas a elas.

Entradas mutáveis

Sim, você pode declarar entradas mutáveis, também conhecidas como variáveis. Para declarar uma entrada mutável, use o caractere til ~:

~ fruta = 'banana'
fruta   = 'abacate'  # ok

Observe que mesmo uma entrada mutável não pode mudar imediatamente seu tipo, a menos que seja apagada do escopo. Para apagar uma entrada, atribua null a ela e, em seguida, redeclare-a com um novo tipo. Mudar tipos é desencorajado pela sintaxe e não é recomendado, mas é possível:

~ color = 32    # cria a entrada color como um número mutável
color = 'blue'  # gera um TypeError porque color é um número
color = null    # a entrada é apagada
color = 'blue'  # redefine color com um tipo diferente (Texto)

você deve declarar a entrada como mutável novamente usando o til ~ ao redefini-la após a exclusão se quiser que o próximo valor seja mutável

Entradas dinâmicas

Você pode criar entradas com nomes dinâmicos usando colchetes [ ref ]:

ref = 'pipoca'  # texto será o nome da entrada

opcoes = { [ref] = 'é saborosa' }

opcoes.[ref]   # sintaxe dinâmica:    'é saborosa', com acesso de leitura e gravação
opcoes(ref)    # sintaxe de obtenção: 'é saborosa', mas o valor é somente leitura
opcoes.pipoca  # sintaxe de ponto:    'é saborosa', mas deve seguir a nomenclatura

todas as declarações dinâmicas são entradas mutáveis

Essa funcionalidade permite definir dinamicamente os nomes dentro de um escopo e criar entradas com nomes que, de outra forma, não seriam aceitos pelo FatScript.

As entradas dinâmicas também podem usar referências numéricas, mas a referência é convertida em texto automaticamente, e.g.:

[ 5 ] = 'texto armazenado na entrada 5'
$self.['5']  # devolve 'texto armazenado na entrada 5'
$self.[5]    # devolve 'texto armazenado na entrada 5'

em um contexto diferente, não seguido por uma atribuição = ou precedido por notação de ponto ., a sintaxe dinâmica será interpretada como uma declaração de lista

Entradas especiais

Entradas com nomes que começam com o sublinhado _ são completamente livres e dinâmicas, não requerem til ~ e também podem mudar de tipo sem a necessidade de apagamento, como variáveis no JavaScript ou Python.

Atribuição por desestruturação

Você pode copiar os valores de um escopo em outro escopo assim:

_ <- fat.math
distancia = (posicao: Scope): Number -> {
  { x, y } = posicao     # atribuição por desestruturação no escopo do método
  sqrt(x ** 2 + y ** 2)  # calcula a distância entre a origem e (x, y)
}
distancia({ x = 3, y = 5 })  # 5.83095189485

Você também pode usar a atribuição por desestruturação para expor um determinado método ou propriedade de uma importação nomeada:

console <- fat.console
{ log } = console
log('Olá Mundo')

usando essa sintaxe com importações, você pode escolher trazer para o escopo atual apenas os elementos da biblioteca que você está interessado em usar, evitando assim a poluição do namespace com nomes que não teriam uso ou poderiam entrar em conflito com os de sua própria autoria

Sintaxe semelhante a JSON

O FatScript também suporta sintaxe semelhante a JSON para declarar entradas:

"nada": null,                  # entrada Void - comportamento distinto, veja abaixo
"estaOnline": true,            # entrada Boolean
"idade": 25,                   # entrada Number
"nome": "João",                # entrada Text
"tags": [ "a", "b" ],          # entrada List
"opcoes": { "prop": "outra" }  # entrada Scope

Embora possa parecer que declarar "nada" cria um valor "nada" de null, é importante observar que a "entrada resultante" na verdade não existe no escopo. Quando você tenta acessar esse "nada", o FatScript retorna null, mas se você tentar mapear o escopo, o nome dessa entrada estará faltando, pois nunca foi realmente criado.

É importante observar que as declarações semelhantes a JSON sempre criam entradas imutáveis, portanto você não pode adicionar o caractere til ~ para torná-las mutáveis.