As variáveis ​​podem conter qualquer tipo de dado, incluindo número, strings, listas ou até mesmo blocos de código.


message := 'Hello, World!'    # Define new variable (alternative: def key value)
message="Bye, bye"          # Edit variable value
def message 'Hello again!'    # Append new 'message' in stack (alternative syntax)
del message                   # Remove last 'message' in stack
message                       # Message has old value 'Bye, bye'
      

As variáveis ​​não são únicas. Você pode declarar vários valores para o mesmo nome de variável usando “:=” e anexar na pilha. Se você quiser editar a última declaração, basta usar o operador “=”. Para remover a última variável com nome específico na pilha, use “del varname”

Você pode retornar o valor de algum item da pilha usando index em vez de var name


num1 = 12                     # If num1 was not previously declared, it'll be
num2 = 23
.                             # Return last item value from stack. 23
. 2                           # Return the second item from stack. 12
      

Basicamente esses três tipos de listas possuem a mesma estrutura, mas agem de forma diferente quando executadas.


# Expressions will be evaluated an return the value
expression = (1 + 2)

# List items are separated by space. Expressions return will be attribuited to item
list = ['first item' (1 + 2)]

# Blocks are lists of expressions that can be called after declaration
block = {
  message := 'OK'
}
      

Para código-fonte ou blocos, cada linha é considerada uma expressão. Para executar um bloco, basta chamá-lo como primeiro item de uma expressão. Os argumentos são anexados à pilha de variáveis ​​do bloco interno


sum = { (. 1) + (. 2) }
# or
def sum { (. 1) + (. 2) }
sum 2 3
      

As listas podem ser enviadas como um contexto anexado ao contexto de variáveis ​​globais.


name := 'Global name'         # Declare a new variable in current stack

person = [
  name := 'Local name'        # The return of this attribution will be the list item.
  age := 20
]

name                          # Return 'Global name'

person :: { name }            # "person" is set as context to block execution.
                              # "name" returns 'Local name'
      

Usando a chamada de contexto, você pode operar itens de listas como variáveis ​​globais


person :: { name="Local" }  # Edit "name" item of "person" list
person :: { del name }        # Remove named item of "person" list
person :: { del (. 1) }       # Remove item of "person" list by index
name                          # Return 'Global name'
      

+ - * /
&& || == != >=  

O operador “+” somará dois números, concatenará duas strings, anexará um nó à lista ou mesclará duas listas.


1 + 2                    # 3
"Kamby" + "Lang"         # KambyLang
[1 2] += 3               # [1 2 3]
list = ([1 2] += [3 4])  # [1 2 3 4]
      

Internamente a implementação segue alguns conceitos básicos como S-expressions e car/cdr como qualquer linguagem Lisp.

Kamby tem algumas convenções para tornar a sintaxe mais amigável:

  • Qualquer coisa que comece com uma nova linha e termine no final da linha é considerada uma expressão
  • Um item formado por 2 ou menos caracteres de pontuação, criará uma expressão formada por (pontuar anterior próximo). Ex.: 2 + 2 => (+ 2 2) … algo == qualquer coisa => (== algo qualquer coisa)
  • Os blocos serão avaliados se for o primeiro item da expressão.

MIT




Source link

Previous articleO que isto significa? – YouVersion
Next articleIsso entre nós Calc eu acidentalmente fiz bagunçando com o preenchimento: webdev

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.