# Referência de Programação em &logo; do &kturtle;

Esta é a referência para o &logo; do &kturtle;. Neste capítulo iremos abordar brevemente todos os tipos de instruções diferentes. Depois, serão explicados os comandos, um por um. Em seguida, serão explicados os recipientes, a matemática, as questões e os controladores de execução. Por último, será mostrado como criar os seus próprios comandos com o learn.

## Tipos Diferentes de Instruções

Como em qualquer linguagem, o LOGO possui diferentes tipos de palavras e símbolos. Aqui as diferenças entre os tipos serão brevemente explanadas.

### Comandos

Usando comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados de entrada, enquanto outros fornecem resultados ou dados de saída.

    # o 'forward' é um comando que necessita de dados de entrada, neste caso o número 100:
    forward 100

Para uma idéia geral de todos os comandos que o &kturtle; suporta, vá para aqui.

### Números

Muito provavelmente você já conhece alguma coisa sobre os números. A forma como eles são usados no &kturtle; não é muito diferente do idioma falado ou da matemática.

Temos então os números conhecidos por naturais: `0`, `1`, `2`, `3`, `4`, `5`, etc. Os números negativos: `-1`, `-2`, `-3`, etc. Finalmente, os números decimais ou fracionários, como por exemplo: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

Os números podem ser usados em cálculos matemáticos e perguntas. Eles também podem ser colocados em recipientes.

Os números ficam realçados em azul no editor de código.

### Cadeias de caracteres

Primeiro um exemplo:

    print "Olá, sou uma cadeia de caracteres."

Neste exemplo, o `print` é um comando, enquanto o `"Olá, sou uma cadeia de caracteres."` é, de fato, uma cadeia de caracteres. Elas começam e terminam com o símbolo `"`; através destes símbolos, o &kturtle; sabe que é uma cadeia de caracteres.

As cadeias de caracteres podem ser colocadas em recipientes. Porém, não podem ser usadas em cálculos matemáticos nem em questões.

As cadeias de caracteres ficam realçadas em vermelho escuro no editor de código.

### Nomes

Ao usar a linguagem de programação &logo;, você pode criar coisas novas. Se criar um programa irá necessitar normalmente de recipientes e, em alguns casos, do learn para criar novos comandos. Ao criar um recipiente ou um novo comando com o learn, você terá que especificar um nome.

Você poderá escolher qualquer nome, desde que ele não tenha já algum significado. Por exemplo, não poderá chamar um recipiente de forward, uma vez que esse nome já é usado para um comando e, assim, já tem um significado.

    # Aqui o forward é usado como recipiente, mas já tem um significado
    # assim irá produzir um erro:
    forward = 20

    # isto funciona:
    forward 20

Os nomes só poderão conter letras, números e sublinhados (_). De qualquer forma, devem começar por uma letra.

Por favor, leia a documentação sobre os recipientes e o comando learn para uma melhor explicação e mais exemplos.

### Atribuições

As atribuições são feitas com o símbolo `=`. Nas linguagens de programação é melhor ler o `=` simples não como um 'é igual a' mas sim como um 'ficar igual a'. O termo 'é igual a' é mais apropriado para o `==`, que é uma pergunta.

As atribuições são usadas normalmente por duas razões, (1) para adicionar conteúdo aos recipientes e (2) para modificar o conteúdo de um recipiente. Por exemplo:

    x = 10
    # o recipiente 'x' contém agora o número 10
    W = "A minha idade é: "
    # o recipiente W contém agora o texto "A minha idade é: "
    # isto imprime o conteúdo dos recipientes 'W' e 'x' na área de desenho
    print W + x

Para mais exemplos, veja a seção que explica os recipientes.

### Símbolos Matemáticos

O &kturtle; suporta todos os símbolos matemáticos básicos: a adição (`+`), a substração (`-`), a multiplicação (`*`), a divisão (`/`) e os parênteses `(` e `)`.

Para uma explicação completa e mais exemplos, veja a seção de matemática.

### Perguntas

Nós podem fazer perguntas simples onde a respostar será 'true' (verdadeiro) ou 'false' (falso).

O uso de perguntas é extensivamente explicado na seção perguntas.

### Palavras de Colagem de Perguntas

As perguntas podem ser coladas juntas com o que se denomina por 'cola das perguntas'. As palavas de colagem são o `and` (e), o `or` (ou) e uma palavra especial: a `not` (não).

A utilização da colagem de perguntas é explicada na seção de Colagem de Perguntas.

### Comentários

Comentários são linhas que iniciam com um `#`. Por exemplo:

    # isto é um comentário!
    print "isto não é um comentário"
    # a linha anterior não é um comentário, mas a próxima é:
    # print "isto não é um comentário"

Nós podemos adicionar comentários ao código para nós mesmos ou para que alguém os leia. Comentários são usados para: (1) adicionar uma pequena descrição ao programa, (2) explanar como um pedaço do código funciona se ele for um pouco complicado, e (3) para 'comentar' linhas de código que devem ser (temporariamente) ignoradas (veja a última linha do exemplo).

As linhas comentadas ficam realçadas em amarelo escuro no editor de código.

## Comandos

Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados de entrada, enquanto outros fornecem resultados ou dados de saída. Nesta seção iremos explicar todos os comandos que podem ser usados no &kturtle;. Observe que todos os comandos incorporados ficam realçados em verde escuro no editor de código, para que possa ajudar a distinguí-los.

### Movendo a tartaruga

Existem vários comandos para mover a tartaruga pela tela.

#### forward (fw)

forward

      forward X

  O `forward` move a tartaruga para a frente X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O `forward` pode ser abreviado para `fw`

#### backward (bw)

backward

      backward X

  O `backward` move a tartaruga para trás X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O `backward` pode ser abreviado para `bw`.

#### turnleft (tl)

turnleft

      turnleft X

  O `turnleft` diz à tartaruga para se virar X graus para a esquerda. O `turnleft` pode ser abreviado para `tl`.

#### turnright (tr)

turnright

      turnright X

  O `turnright` diz à tartaruga para se virar X graus para a direita. O `turnright` pode ser abreviado para `tr`.

#### direction (dir)

direction

      direction X

  O `direction` configura a direção da tartaruga para um ângulo de X graus a contar do zero, e isto não é relativo à direção anterior da tartaruga. O `direction` pode ser abreviado para `dir`.

#### center

center

      center

  O `center` move a tartaruga para o centro da área de desenho.

#### go

go

      go X,Y

  O `go` manda a tartaruga ir para um determinado local da área de desenho. Este local está a X pixels do lado esquerdo da área de desenho e a Y pixels do topo da área. Lembre-se que, ao usar o comando `go`, a tartaruga não irá desenhar nenhuma linha.

#### gox

gox

      gox X

  Ao usar o comando `gox`, a tartaruga irá mover-se X pixels a partir da esquerda da área de desenho, mantendo-se na mesma altura.

#### goy

goy

      goy Y

  Ao usar o comando `goy`, a tartaruga irá mover-se Y pixels a partir do topo da área de desenho, mantendo-se na mesma distância do lado esquerdo da área de desenho.

### A tartaruga tem um traço

A tartaruga tem um traço e vai desenhando uma linha à medida que a tartaruga se move. Existem alguns comandos para controlar o traço. Nesta seção iremos explicar estes comandos.

#### penup (pu)

penup

      penup

  O `penup` levanta o traço da área de desenho. Quando o traço está em cima, não é desenhada nenhuma linha à medida que a tartaruga se move. Veja também o `pendown`. O `penup` pode ser abreviado para `pu`.

#### pendown (pd)

pendown

      pendown

  O `pendown` pressiona o traço para baixo na área de desenho. Quando o traço está em baixo, é desenhada uma linha à medida que a tartaruga se move. Veja também o `penup`. O `pendown` pode ser abreviado para `pd`.

#### penwidth (pw)

penwidth

      penwidth X

  O `penwidth` configura a espessura do traço para X pixels. O `penwidth` pode ser abreviado para `pw`.

#### pencolor (pc)

pencolor

      pencolor R,G,B

  O `pencolor` configura a cor do traço. O `pencolor` recebe uma combinação de RGB como parâmetro. O `pencolor` pode ser abreviado para `pc`.

### Comandos para controlar a área de desenho

Existem vários comandos para controlar a área de desenho.

#### canvassize (cs)

canvassize

      canvassize X,Y

  Com o comando `canvassize` você poderá alterar o tamanho da área de desenho. Ele recebe dois parâmetros (X e Y) de entrada, em que o X é a nova largura da área de desenho em pixels, e o Y é a nova altura da mesma área em pixels. O `canvassize` pode ser abreviado para `cs`.

#### canvascolor (cc)

canvascolor

      canvascolor R,G,B

  O `canvascolor` define a cor da área de desenho. O `canvascolor` recebe uma combinação RGB como parâmetro. O `canvascolor` pode ser abreviado para `cc`.

#### wrapon

wrapon

      wrapon

  Com o comando `wrapon` você poderá ativar a envolvência para a área de desenho. Por favor veja o glossário para saber o que é a envolvência.

#### wrapoff

wrapoff

      wrapoff

  Com o comando `wrapoff` você poderá desativar a envolvência para a área de desenho. Isto significa que a tartaruga poderá mover-se para fora da área de desenho e perder-se. Por favor veja o glossário se quiser saber o que é a envolvência.

### Comandos para limpar

Existem dois comandos para limpar a área de desenho, depois de você ter deixado tudo bagunçado.

#### clear (cr)

clear

      clear

  Com o `clear`, você poderá limpar todos os desenhos da área de desenho. Todo o resto permanece igual: a posição e o ângulo da tartaruga, a cor da área de trabalho, a visibilidade da tartaruga e o tamanho da área de desenho. O `clear` pode ser abreviado para `cr`.

#### reset

reset

      reset

  O `reset` limpa tudo de forma mais abrangente que o comando `clear`. Depois de um comando `reset`, tudo fica como estava quando você iniciou o &kturtle;. A tartaruga é posicionada no meio do tela, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho.

### A tartaruga é uma imagem móvel

Muitas pessoas não sabem o que são as imagens móveis ('sprites'), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer o tela (para mais informações, veja o glossário sobre as imagens móveis).

A seguir você irá encontrar uma apresentação completa de todos os comandos que lidam com imagens móveis.

[A versão atual do &kturtle; não suporta ainda o uso de imagens móveis além da tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa que desejar]

#### show

show (ss)

      show

  O `show` torna a tartaruga visível de novo depois de ter ficado escondida. O `show` pode ser abreviado para `ss`.

#### hide (sh)

hide

      hide

  O `hide` esconde a tartaruga. Isto pode ser usado se a tartaruga não couber no seu desenho. O `hide` pode ser abreviado para `sh`.

### Será que as tartarugas sabem escrever?

A resposta é: sim. A tartaruga sabe escrever e pode escrever tudo o que lhe disser para escrever.

#### print

print

      print X

  O comando `print` é usado para dizer à tartaruga para escrever algo na área de desenho. O `print` recebe números e texto como parâmetros. Você poderá executar o `print` para vários parâmetros com o sinal +. Veja aqui um pequeno exemplo:

      ano = 2004
      autor = "Ze"
      print "O " + autor + " iniciou o projeto do KTurtle em " + ano + " e ainda continua gostando de trabalhar nele!"

#### fontsize

fontsize

      fontsize X

  O `fontsize` configura o tamanho da letra que é usado pelo `print`. O `fontsize` recebe um parâmetro que deverá ser um número. O tamanho é definido em pixels.

### Um comando que joga aos dados para você

Existe um comando que lança os dados para você, que se chama `random`; ele é muito útil para alguns resultados inesperados.

random

      random X,Y

  O `random` é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, onde o primeiro define o resultado mínimo (X) e o segundo o máximo (Y). O resultado é um número escolhido aleatoriamente que é maior ou igual ao mínimo e menor ou igual ao máximo. Aqui está um pequeno exemplo:

            repeat 500 [
              x = random 1,20
              forward x
              turnleft 10 - x
            ]

  Com o comando 'random', você poderá adicionar um pouco de confusão ao seu programa.

### Entrada de dados e reação através de janelas

Uma janela poderá pedir alguma alguma reação em especial ou a introdução de determinados dados. O &kturtle; tem dois comandos para janelas, nomeadamente o `message` e o `inputwindow`

#### message

message

      message X

  O comando `message` recebe uma cadeia de caracteres como entrada. Mostra então uma janela que contém o texto da cadeia de caracteres.

      ano = 2004
      autor = "Ze"
      print "O " + autor + " iniciou o projeto do KTurtle em " + ano + " e ainda continua gostando de trabalhar nele!"

#### inputwindow

inputwindow

      inputwindow X

  O `inputwindow` recebe uma cadeia de caracteres como entrada. Mostra uma janela que contém o texto da cadeia de caracteres, tal como acontece no message. Contudo, além disso, também mostra um campo de texto na janela. Através deste campo, o usuário poderá introduzir um número ou uma cadeia de caracteres que poderá ser guardada num recipiente. Por exemplo

      in = inputwindow "Que idade você tem?"
      out = 2003 - in
      print "Em 2003, você tinha " + out + " anos em determinado momento."

  Quando um usuário cancelar a janela ou não inserir nenhuma informação, o recipiente fica vazio.

## Recipientes

Os recipientes são letras ou palavras que podem ser usadas pelo programador para guardar algum número ou algum texto. Os recipientes que contém um número chamam-se variáveis, enquanto que os que contém texto chamam-se cadeias de caracteres.

Os recipientes que não são usados não contém nada. Por exemplo, um:

    print N

Isto não irá imprimir nada. Se tentar fazer operações matemáticas com recipientes vazios, irá obter erros.

### Variáveis: recipientes de números

Vamos começar com um exemplo:

    x = 3
    print x

Na primeira linha, a letra `x` passou a ser uma variável (um recipiente de números). Como você pode ver, o valor da variável `x` passou para 3. Na segunda linha, o valor é impresso.

Lembre-se que, se quisermos imprimir um x, então devemos escrever

    print "x"

Isso foi fácil, mas agora há um exemplo um pouco mais difícil:

    A = 2004
    B = 25
    C = A + B

    # o próximo comando imprime "2029"
    print C
    backward 30
    # o próximo comando imprime "2004 mais 25"
    print A + " mais " + B
    backward 30
    # o próximo comando imprime "1979"
    print A - B

Nas duas primeiras linhas, as variáveis `A` e `B` são configuradas como sendo iguais a 2004 e 25. Na terceira linha, a variável `C` fica igual a `A + B`, o que dá 2029. O resto do exemplo consiste em 3 comandos `print` com `backward 30` no meio. O `backward 30` está lá para garantir que cada resultado fica numa linha diferente. Neste exemplo, você vê também que as variáveis podem ser usadas nos cálculos matemáticos.

### Recipientes de texto (cadeias de caracteres)

No código do programa, o texto normal é iniciado e termina normalmente com aspas. Como já foi visto:

    print "Olá programador!"

O texto fica delimitado com as aspas. Estes pedaços de texto normal são chamados então de cadeias de caracteres.

As cadeias de caracteres são bastante parecidas com as variáveis. A maior diferença é que as cadeias de caracteres não podem ser usadas em cálculos matemáticos e perguntas. Um exemplo da utilização das cadeias de caracteres:

    x = "Olá "
    nome = inputwindow "por favor insira o seu nome..."
    print x + nome + ", como está?

Na segunda linha, a cadeia de caracteres `x` fica igual a Olá . Na segunda linha, a cadeia de caracteres `nome` é configurada como o resultado do comando `inputwindow`. Na terceira linha, o programa imprime uma composição de três cadeias de caracteres na área de desenho.

Este programa pede para inserir o seu nome. Quando você, por exemplo, inserir o nome José, o programa irá imprimir Olá José, como está?. Lembre-se que o sinal de mais (+) é o único símbolo matemático que você poderá usar com as cadeias de caracteres.

## Será que a Tartaruga sabe fazer contas?

Sim, o &kturtle; sabe fazer contas para você. Você poderá somar (+), subtrair (-), multiplicar (*) e dividir (/). Aqui está um exemplo no qual iremos usar todas as operações:

    a = 20 - 5
    b = 15 * 2
    c = 30 / 30
    d = 1 + 1
    print "a: "+a+", b: "+b+", c: "+c+", d: "+d

Será que você sabe o valor de 'a', 'b', 'c' e 'd'? Repare por favor no uso do símbolo `=` de atribuição.

Se você somente queria fazer um cálculo simples, você poderá fazer algo semelhante a isto:

    print 2004-12

Agora, um exemplo com parênteses:

    print ( ( 20 - 5 ) * 2 / 30 ) + 1

O que estiver entre parênteses será calculado em primeiro lugar. Neste exemplo, o 20-5 será calculado, depois será multiplicado por 2, dividido por 30 e depois é adicionado 1 (o que dá 2).

## Fazendo perguntas, obtendo respostas...

O `if` e o `while` são controladores de execução que iremos discutir na próxima seção. Nesta seção iremos usar o comando `if` para explicar as perguntas.

### Perguntas

Um exemplo simples de pergunta:

    x = 6
    if x > 5 [
      print "olá"
    ]

Neste exemplo, a pergunta é `x > 5`, se a resposta a esta pergunta for true (verdadeira), o código entre colchetes será executado. As perguntas são uma parte importante da programação e são usadas normalmente em conjunto com os controladores de execução, como o `if`. Todos os números e variáveis (recipientes de números) poderão ser comparados uns com os outros nas perguntas.

Aqui estão todas as perguntas possíveis:

#### Tipos de perguntas

`a == b` | é igual a | a resposta é true (verdadeira) se o `a` for igual ao `b`
`a != b` | é diferente de | a resposta é true (verdadeira) se o `a` não for igual ao `b`
`a > b` | maior que | a resposta é true (verdadeira) se o `a` for maior que o `b`
`a < b` | menor que | a resposta é true (verdadeira) se o `a` for menor que o `b`
`a >= b` | maior ou igual a | a resposta é true (verdadeira) se o `a` for maior ou igual ao `b`
`a <= b` | menor ou igual a | a resposta é true (verdadeira) se o `a` for menor ou igual ao `b`

As perguntas ficam realçadas em azul claro no editor de código.

### Colagem de Perguntas

As perguntas também podem ser coladas umas às outras com palavras de colagem de perguntas onde, desta forma, algumas perguntas tornam-se uma pergunta maior.

    a = 1
    b = 5
    if (a < 5) and (b == 5) [
      print "olá"
    ]

Neste exemplo, a palavra de colagem `and` é usada para colar 2 perguntas (`a < 5`, `b == 5`) juntas. Se um lado do `and` der uma resposta false (falsa), a pergunta toda irá responder false, porque, com a palavra de colagem `and`, ambos os lados precisam ser true para que a resposta seja true (verdadeira). Por favor não se esqueça de usar os parênteses ao redor das perguntas!

Aqui está uma visão esquemática, bem como uma explicação mais detalhada:

#### Palavras de colagem de perguntas

`and` | ambos os lados têm que ser true (verdadeiros) para a resposta ser true (verdadeira)
`or` | se um dos lados for true (verdadeiros) a resposta é true (verdadeira)
`not` | Caso especial: só funciona com uma pergunta! Muda o 'true' para 'false' e o 'false' para 'true'.

As palavras de colagem ficam realçadas em púrpura no editor de código.

#### and

Quando são coladas duas perguntas juntas com o `and`, ambos os lados do `and` terão que ser 'true' para que o resultado também seja 'true' (verdadeiro). Por exemplo:

    a = 1
    b = 5
    if ((a < 10) and (b == 5)) and (a < b) [
      print "olá"
    ]

Nestes exemplo, você poderá ver uma pergunta colada a outra pergunta também colada.

#### or

Se uma das duas perguntas coladas juntas com o `or` for 'true' (verdadeira), o resultado será também 'true'. Por exemplo:

    a = 1
    b = 5
    if ((a < 10) or (b == 10)) or (a == 0) [
      print "olá"
    ]

Neste exemplo, irá ver uma pergunta colada a outra pergunta, que também está colada.

#### not

O `not` é uma palavra de colagem especial porque somente funciona com uma pergunta de cada vez. `not` muda 'true' para 'false' e 'false' para 'true'. Um exemplo:

    a = 1
    b = 5
    if not ((a < 10) and (b == 5)) [
      print "olá"
    ]
    else
    [
      print "adeus ;-)"
    ]

Neste exemplo a pergunta colada é 'true' ainda que o `not` mude-a para 'false'. Assim, no final, `"adeus ;-)"` é impresso na área de desenho.

## Controlando a execução

Os controladores de execução permitem-lhe — como o nome deles indica — controlar a execução.

Os comandos de controle de execução são realçados em verde escuro e negrito. Os colchetes são frequentemente usados juntamente com os controladores de execução e eles são realçados em verde claro.

### Fazendo a tartaruga esperar

Se você já tentou programar um pouco no &kturtle;, você já poderá ter reparado que a tartaruga pode ser bastante rápida desenhando. Este comando faz a tartaruga andar um pouco mais devagar.

wait

      wait X

  O `wait` faz a tartaruga esperar X segundos.

      repeat 36 [
        forward 5
        turnright 10
        wait 0.5
      ]

  Este código irá desenhar uma circunferência, mas a tartaruga irá esperar meio segundo a cada passo. Isto dá a noção de uma tartaruga vagarosa.

### Executar o "if"

if

      if pergunta [ ... ]

  O código que é colocado no ... só será executado se (`if`) a resposta à pergunta for true (verdadeira). Por favor leia, para obter mais informações sobre perguntas, a seção de perguntas.

      x = 6
      if x > 5 [
        print "O x é maior que cinco!"
      ]

  Na primeira linha, o `x` é inicializado com 6. Na segunda linha, a pergunta `x > 5` é feita. Uma vez que a resposta a esta pergunta é verdadeira, o controlador de execução `if` irá permitir que o código entre colchetes seja executado

### O ciclo "while"

while

      while pergunta [ ... ]

  O controlador de execução `while` é um pouco parecido com o `if`. A diferença é que o `while` fica repetindo (em ciclo) o código entre os colchetes até que a resposta à pergunta seja false.

      x = 1
      while x < 5 [
        forward 10
        wait 1
        x = x + 1
      ]

  Na primeira linha o `x` é inicializado com 1. Na segunda linha a pergunta `x < 5` é feita. Uma vez que a resposta é verdadeiro o controlador de execução `while` inicia a execução do código entre colchetes até que a resposta à pergunta seja falso. Neste caso o código entre colchetes será executado 4 vezes, porque cada vez que a quinta linha é executada o `x` é aumentado de 1.

### Se não, em outras palavras: "else"

else

      if pergunta [ ... ] else [ ... ]

  O `else` pode ser usado em adição ao controlador de execução `if`. O código entre colchetes após o `else` só é executado se a resposta à pergunta feita é respondida como falso.

      reset
      x = 4
      if x > 5 [
        print "x é maior que cinco!"
      ]
      else
      [
        print "x é menor que seis!"
      ]

  A pergunta feita é se `x` é maior que 5. Uma vez que `x` é inicializado com 4 na primeira linha a resposta à questão é falso. Isto significa que o código entre colchetes após o `else` será executado.

### O ciclo "for", um ciclo de contagem

for

      for ponto inicial a ponto final [ ... ]

  O ciclo `for` é um ciclo de contagem, ou seja, faz um contador para você.

      for x = 1 to 10 [
        print x * 7
        forward 15
      ]

  Cada vez que o código entre parênteses é executado, o `x` é incrementado de uma unidade, até que o valor do `x` chegue a 10. O código entre parênteses imprime o valor de `x` multiplicado por 7. Depois de este programa terminar a sua execução, você irá ver a tabuada dos 7 na área de desenho.

## Crie os seus próprios comandos com o learn

O `learn` é um comando muito especial, porque ele é usado para criar seus próprios comandos. O comando que você criar pode ter valores de entrada e retornar valores de saída. Vamos dar uma olhada em como um novo comando é criado:

    learn circulo x [
      repeat 36 [
        forward x
        turnleft 10
      ]
    ]

O novo comando é chamado `circulo`. `circulo` recebe um valore de entrada, um número, para configurar o tamanho do círculo. `circulo` não retorna nenhum valor de saída. O comando `circulo` pode agora ser usado como um comando normal no resto do código. Veja este exemplo:

    learn circulo (x) [
      repeat 36 [
        forward x
        turnleft 10
      ]
    ]

    go 30,30
    circulo 20

    go 40,40
    circulo 50

No próximo exemplo, um comando com valor de retorno é criado.

    reset

    learn multPorSi n [
      r = n * 1
      r = n * n
      return r
    ]
    i = inputwindow "Por favor insira um número e pressione OK"
    print i + " multiplicado por ele mesmo é: " + multPorSi i

Neste exemplo um novo comando chamado `multPorSi` é criado. A entrada deste comando é multiplicada por ela mesmo e então retornada, usando o comando `return`. O comando `return` é a maneira de retornar um valor a partir de uma função que você criou.