Base da linguagem

Tucano será uma linguagem orientada a objetos, então haverá classes, herança, filhos e pais, além de tipagem forte porém não necessária.

A linguagem requer uma função inicio a ser declarada no arquivo principal do projeto, que possuirá o mesmo nome do projeto, com o sufixo .tc. Assim, um projeto nomeado teste possuirá o arquivo teste.tc que obrigatoriamente possui funcao inicio dentro.

A linguagem utilizará {} para abrir e fechar laços de código, e () para determinar argumentos de função, sendo assim a função inicio deverá ser escrita como: 

funcao inicio() {

}

Sendo uma linguagem escrita em português, o compilador ignorará caracteres especiais como ç e acentos em palavras reservadas, então funcao, funçao, função e funcão são equivalentes ao compilador.

A determinação de tipo de função ocorrerá com o uso de um : depois do fim dos argumentos, assim, por exemplo, uma função adição que soma dois números seria: 

funcao soma(x:int,y:int):int {
  retorna x+y
}

Pelo exemplo acima percebe-se que o : pode ser usado nos argumentos também para especificar seu tipo.

Em Tucano o caractere fim de linha (\n) é usado para interpretar o fim de um comando, logo ; é desnecessário, mas é uma opção para quando se quer escrever vários comandos em uma só linha, então: 

int x
caractere y

e

int x; caractere y

executarão exatamente o mesmo código.

Comentários

Em Tucano, os comentários são escritos com -- antes do comentário e continua até o fim da linha (\n): 

var x = 5 --isso é um comentário
--isso também.

Tipos de variáveis

int

caractere

lógico

real

Declaração de variáveis

A declaração de variáveis deve ser feita antes do uso da mesma, especificando ou não seu tipo, e inicializando ou não seu valor.

A palavra chave para criação de variáveis sem tipo é var. 

var x = 10 --Variável do tipo int
var y = 10.0 --Variável do tipo real
var z = "oi" --Variável do tipo caractere

caractere teste = 10 --Erro de sintaxe: variável teste do tipo caractere não pode receber valor do tipo int

Para declarar uma lista, se digita [] depois do tipo. Se desejar um array de tamanho fixo, é só digitar o tamanho dentro dos colchetes, se não, deixe-os vazios que uma lista dinâmica será criada: 

caractere[] listadecompras = ["Alface","Tomate"]

Não se pode fazer var[] dada a natureza da lista.

Matrizes podem ser alcançadas fazendo um truque simples: 

int[][] matriz

Essa linha de código cria uma lista de listas de inteiros, que funciona como uma matriz.

Operadores

Os operadores de comparação são os seguintes:

== igualdade
>= maior que ou igual a
<= menor que ou igual a
> maior que
< menor que
~= não é igual a

Importante: diferente do Javascript, todas as comparações em Tucano são estritas ao tipo, então 10=="10" retornará falso.

O operador ternário existe em Tucano, sendo utilizado da seguinte forma: 

logico éDia = falso
caractere relogio = éDia ? "Tá de dia" : "Tá de noite"

Os operadores matemáticos são os seguintes:

+ soma
- subtração
* multiplicação
/ divisão
^ exponenciação
// divisão inteira
% módulo, resto
.. concatenação

Os operadores lógicos são:

e
ou
xou

Os operadores de matemática discreta são:

& bitwise-and
| bitwise-or
~ negate
^| bitwise-xor

O operador = é usado para assinalar um valor a uma variável.

Podemos combiná-lo com os operadores matemáticos para encurtar as linhas de código: 

+= soma
-= subtração
*= multiplicação
/= divisão
^= exponenciação
//= divisão inteira
%= módulo, resto

É importante lembrar que não podemos fazer isso com os operadores de matemática discreta, reservando-os apenas a escrita mais longa: 

int x = 10
x += 5
-- x agora vale 15
x //= 4
-- x agora vale 3
x = x & 2
-- 11 & 10 = 10
-- x agora vale 2
x &= 3 --Erro de sintaxe: '&' inesperado encontrado.

Condições

Usando o comando se podemos conferir uma condição: 

logico sim = verdadeiro
se (sim) {
  --faça algo se for verdadeiro
}

Podemos também usar o senão para conferir o oposto da condição: 

logico nao = falso
se (nao) {
  --faça algo se for verdadeiro
} senao {
  --faça algo se for falso
}

O senão pode ser combinado com um se: 

logico nao = falso
se (nao) {
  --faça algo se for verdadeiro
} senao se (nao == falso) {
  --faça algo se for falso
}

Usando o comando escolha..caso podemos conferir várias condições: 

int x = 10
escolha (x) {
  caso 1:
    --faça algo
  caso 2:
    --faça outra coisa
  caso padrão:
    --faça isso
}

Laços de repetição

Usando o comando para podemos criar um laço de repetição finito: 

para (i=1,10) faca {
  --ambos os parametros são inclusivos
}

caractere[] lista = {"Alface","Batata"}
para (vegetal de lista) faca {
  --variavel vegetal vai iterar por todos itens da variavel lista
}

para (i=0,lista.tamanho()-1) faca {
  var vegetal = lista[i]
  --esse código é virtualmente idêntico ao mostrado acima
}

para (i=10,1) passo -1 faca {
  --passo é usado para determinar o quanto o para deve avançar por iteração
  --quando o valor inicial é maior que o final e o passo não for explícito, o padrão é -1
}

para (i=0,20) passo 2 faca {
  --esse para irá iterar por todos os números pares até o vinte
}

Podemos também usar o laço enquanto de tal maneira: 

int x = 1
enquanto (x<10) {
  --isso se repetirá enquanto x for menor que 10
  --para isso ser útil, não se esqueça de incrementar o x no fim:
  x += 1
}

Podemos usar o repita..até também: 

int x = 1
repita até (x >= 10) {
  --isso se repetirá até que x seja maior ou igual a 10.
  --para isso ser útil, não se esqueça de incrementar o x no fim:
  x += 1
}

Podemos usar o escapar para sair de um laço de repetição: 

int x = 1
enquanto (verdade) {
  --Este é um laço de repetição infinito.
  x += 1
  se (x >= 10) {
    escapar --isso vai sair do laço se x for maior ou igual a 10.
  }
}

Entrada e Saída

Entrada e Saída de dados são gerenciados pelos objetos Entrada e Saida.

Exemplo de entrada:

funcao inicio() {
  caractere texto = Entrada.leia()
  --Esse código irá ler a primeira linha de texto que o usuário digitar no console
}

Exemplo de saída:

funcao inicio() {
  Saida.escreval("Olá mundo!")
}

Classes

Para declarar uma classe você deve especificar seu nome e construtor, usando a palavra classe você pode criar a classe, com seus atributos e métodos, dos quais um método obrigatório será o construtor que é usado quando você instancia essa classe. O construtor deverá sempre retornar a classe que ele está: 

classe Fruta {

  caractere nome

  funcao construtor(n:caractere) {
    isso.nome = n
    retorna isso
  }

}

Dentro da classe você pode usar o isso para se referir a instância de objeto que está executando. Suponhamos a seguinte classe: 

classe Fruta {

  privado caractere nome

  publico funcao construtor(n:caractere):Fruta {
    isso.nome = n
    retorne isso
  }
  publico funcao falarNome() {
    Saida.escreval(isso.nome) --escreva na tela o nome dessa fruta
  }
}

funcao inicio() {

  Fruta uva = novo Fruta("uva") --criar um objeto fruta com nome uva
  Fruta melao = novo Fruta("melao") --criar um objeto fruta com nome melao

  melao.falarNome() --o melao vai escrever "melao" na tela pois é essa instancia que está executando.
}

Gráficos

Embora não seja parte da linguagem em si, faz parte da biblioteca padrão da linguagem, e fornece um objeto Tela que pode ser usado: 

funcao inicio() {
  Tela.iniciar() --Não é necessário no Tucano Play, mas inicializa uma tela 1080x720
}

Com essa classe você pode fazer muita coisa, incluindo desenhar na tela: 

funcao inicio() {
  Tela.cor(0.5,0.5,1) --Muda a cor da saída para azul
  Tela.retangulo(Tela.CHEIO,0,0,100,150) --desenha um retangulo preenchido nas coordenadas 0,0 de tamanho 100x150
}