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.