# Manual de referencia do programador de &turtlelang;

Este é o manual de referencia do &turtlelang; de &kturtle;. Neste capítulo primeiro descreberemos brevemente os diferentes tipos de instruccións, e logo explicaranse os comandos un por un. Despois explícanse os contedores, as matemáticas, as perguntas e os controladores da execución. Finalmente explícase como crear os seus proprios comandos mediante define.

## Os tipos de instrucións

Como en calquera linguaxe, &turtlelang; ten tipos diferentes de palabras e símbolos. Aquí explícanse brevemente as diferenzas entre os tipos.

### Comandos

Empregando comandos dille ao sapoconcho de &kturtle; que faga algo. Algúns comandos precisan dunha entrada, outros xeran unha saída.

    # avanza é un comando que precisa dunha entrada, neste caso o número 100:
    avanza 100

Para coñecer máis detalles acerca de todos os comandos soportados por &kturtle; vaia aquí.

### Números

Posibelmente xa saiba bastante acerca dos números. A maneira de utilizar os números en &kturtle; non é moi diferente da oral, nen da matemática.

Temos os números naturais: `0`, `1`, `2`, `3`, `4`, `5` etc, os números negativos: `-1`, `-2`, `-3` etc. E tamén temos números con parte decimal, por exemplo: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

Os números poden ser utilizados en cálculos matemáticos e perguntas. Tamén poden porse en contedores.

Os números aparecen realzados en vermello escuro no editor do código.

### Textos

Primeiro un exemplo:

    escrebe "Olá, son un texto."

Neste exemplo `escrebe` é un comando no que `"Olá, son un texto."` é un texto. Os textos comezan e rematan con aspas, `"`, mediante as cais &kturtle; sabe que é un texto.

Os textos poden porse en contedores. Aínda así non poden ser empregados en cálculos matemáticos ou perguntas.

Os textos son realzados en vermello no editor do código.

### Nomes

Cando empregue a linguaxe de programación &turtlelang; pode crear novos textos. Se escrebe un programa a miúdo precisará contedores e nalgúns casos define para crear novos comandos. Cando faga un novo comando con define terá que especificar un nome.

Pode escoller calquera nome mentres non teña xa asinado un significado. Por exemplo non pode crear unha función chamada avanza, porque este nome xa é empregado por un comando interno.

    # aquí emprégase avanza como un comando novo,
    # pero xa ten un significado, polo que
    # dará un erro:
    define avanza {
      escrebe "isto non é válido"
    }

    # isto funciona:
    define adianta {
      escrebe "isto serve"
    }

Os nomes só poden conter letras, número e trazos baixos (_), e teñen que comezar por unha letra. Os nomes de contedor teñen que comezar co prefixo de contedor ($).

    # aquí emprégase avanza como un contedor,
    # polo que se prefixa cun $, polo que non
    # entra en conflito co comando avanza
    $avanza = 20
    escrebe $avanza

Os contedores reálzanse en letra grosa púrpura no editor do código.

Lea a documentación acerca dos contedores e do comando define para ter mellores explicacións e máis exemplos.

### Asinacións

As asinacións fanse mediante o símbolo `=`. Nas linguaxes de programación é mellor ler o `=` non como "é igual a" senón como "faise". A expresión "é igual a" é máis apropriada para o `==` que é unha pergunta.

Polo xeral as asinacións empréganse por dous motivos, (1) para engadir contido aos contedores, e (2) para modificar o contido dun contedor. Por exemplo:

    $x = 10
    # o contedor x agora contén o número 10
    $W = "A miña idade é: "
    # o contedor W agora contén o texto "A miña idade é: "
    # isto que segue escrebe o contido dos contedores "W" e "x"
    escrebe $W + $x

Para máis exemplos consulte a sección que explica os contedores.

### Símbolos matemáticos

&kturtle; admite os símbolos matemáticos básicos: suma (`+`), resta (`-`), multiplicación (`*`), división (`/`) e os parénteses `(` e `)`.

Para recibir unha explicación completa e máis exemplos consulte a sección de matemáticas.

### Perguntas

Podemos facer perguntas simples nas que a resposta sexa "certo" ou "falso".

O uso das perguntas é explicado en detalle na sección de perguntas.

### Encadeamento de perguntas

As perguntas poden combinarse mediante as palabras-chave `e`, `ou` e unha palabra especial: `non`.

A utilización destas palabras-chave explícase na sección Combinación de perguntas.

### Comentarios

Os comentarios son liñas que comezan cun `#`. Por exemplo:

    # isto é un comentario!
    escrebe "isto non é un comentario"
    # a liña previa non é un comentario, pero a seguinte si o é:
    # escrebe "isto non é un comentario"

Podemos engadir comentarios no código para axudarnos a nós mesmos ou a outras persoas a comprender o que fai. Os comentarios son utilizados para: (1) engadir unha pequena descrición do programa, (2) explicar como funciona un pedazo de código se é algo lioso, e (3) para "comentar" liñas de código que deben ser ignoradas temporalmente (por exemplo a última liña do exemplo anterior).

As liñas comentadas son realzadas en gris claro no editor do código.

## Comandos

Mediante os comandos pode dicirlle ao sapoconcho ou a &kturtle; que faga algo. Algúns comandos precisan de parámetros, outros xeran un resultado. Nesta sección explicamos todos os comandos que poden ser empregados en &kturtle;. Lembre que todos os comandos incorporados que se explican aquí serán realzados en azul no editor do código, o que o axudará a distinguilos.

### Mover o sapoconcho

Hai varios comandos que moven o sapoconcho pola pantalla.

avanza (av)

-     avanza X

  `avanza` move o sapoconcho cara diante X píxeles. Cando o lápis está pousado deixará un rastro. `avanza` pode abreviarse como `av`

recua (re)

-     recua X

  `recua` move o sapoconcho cara atrás X píxeles. Se o lápis está pousado deixará un rastro. `recua` pode ser abreviado como `re`.

xiraesquerda (xe)

-     xiraesquerda X

  `xiraesquerda` ordénalle ao sapoconcho que xire X graus á esquerda. `xiraesquerda` pode abreviarse como `xe`.

xiradereita (xd)

-     xiradereita X

  `xiradereita` ordénalle ao sapoconcho que xire X graus á dereita. `xiradereita` pode abreviarse como `xd`.

direccion (dir)

-     direccion X

  `direccion` fai que o sapoconcho tome unha ruta a X graus do cero, polo que non é relativa á anterior ruta que seguise o sapoconcho. `direccion` pode abreviarse como `dir`.

vaiaocentro

-     vaiaocentro

  `vaiaocentro` leva o sapoconcho ao centro do lenzo.

vai

-     vai X,Y

  `vai` fai que o sapoconcho vaia a un lugar concreto do lenzo. Este lugar está a X píxeles do borde esquerdo do lenzo e a Y píxeles da parte de riba do lenzo.

vaix

-     vaix X

  `vaix` fai que o sapoconcho vaia a unha posición situada a X píxeles do borde esquerdo do lenzo sen desprazarse en altura.

vaiy

-     vaiy Y

  `vaiy` fai que o sapoconcho vaia a unha posición situada a Y píxeles do cume do lenzo sen desprazarse en horizontal.

Cando se utilizan os comandos `vai`, `vaix`, `vaiy` e `vaiaocentro` o sapoconcho non debuxa a liña, con independencia de que o lápis estexa erguido ou pousado.

### Onde está o sapoconcho?

Hai dous comandos que din a posición do sapoconcho na pantalla.

coordenadaX

- `coordenadaX` devolve a cantidade de píxeles que hai desde a esquerda do lenzo até a posición do sapoconcho.

coordenadaY

- `coordenadaY` devolve a cantidade de píxeles que hai do cume do lenzo até a posición do sapoconcho.

### O sapoconcho ten un lápis

O sapoconcho ten un lápis que debuxa unha liña á medida que se move o animal. Hai uns poucos comandos que controlan este lápis. Nesta sección explicarémolos.

subelapis (sl)

-     subelapis

  `subelapis` separa o lápis do lenzo. Cando o lápis está subido non se debuxan liñas ao moverse o sapoconcho. Consulte tamén `baixalapis`. `subeLapis` pode abreviarse como `sl`.

baixalapis (bl)

-     baixalapis

  `baixalapis` pousa o lápis no lenzo. Cando o lápis está baixado debúxanse liñas cando se move o sapoconcho. Consulte tamén `subelapis`. `baixalapis` pode abreviarse como `bl`.

ancholapis (al)

-     ancholapis X

  `ancholapis` estabelece o grosor do trazo co valor de X píxeles. `ancholapis` pode abreviarse como `al`.

corlapis (cl)

-     corlapis R,G,B

  `corlapis` estabelece a cor do trazo. `corlapis` toma como parámetro unha combinación RGB. `corlapis` code abreviarse como `cl`.

### Comandos para controlar o lenzo

Hai varios comandos que controlan o lenzo.

tamañolenzo (tlz)

-     tamañolenzo X,Y

  Mediante o comando `tamañolenzo` pode axustar o tamaño da área. Toma X e Y como entradas, onde X é o novo ancho do lenzo en píxeles e Y é o novo alto en píxeles. `tamañolenzo` pode abreviarse como `tlz`.

corlenzo (clz)

-     corlenzo R,G,B

  `corlenzo` estabelece a cor do lenzo. `corlenzo` toma unha combinación RGB como entrada. `corlenzo` pode abreviarse como `clz`.

### Comandos para borrar

Hai dous comandos para limpar o lenzo cando o emborrona.

borra (br)

-     borra

  Con `borra` pode borrar do lenzo todos os debuxos. As demais cousas fican: a posición e ángulo do sapoconcho, a cor do lenzo, a visibilidade do sapoconcho e o tamaño do lenzo.

reinicia

-     reinicia

  `reinicia` limpa máis a fondo do que o fai o comando `borra`. Despois de executar un comando `reinicia` todo volta a ser como cando iniciou &kturtle;. O sapoconcho estará posto no centro da pantalla, a cor do lenzo será branco, debuxarase cun trazo negro e o tamaño do lenzo será de 400 x 400 píxeles.

### O sapoconcho é un sprite

Os sprites son pequenas imaxes que se poden mover pola pantalla, como se ve nos xogos de consola. O noso animaliño tamén é un sprite. Para saber máis acerca disto, consulte a entrada sprites no glosario.

A seguir ten un resumo completo de todos os comandos que traballan sobre sprites.

[A versión actual de &kturtle; aínda non permite utilizar outros sprites que non sexan o sapoconcho. En versións futuras poderá mudar para outro deseño á súa escolla]

mostrasapoconcho (msc)

-     mostrasapoconcho

  `mostrasapoconcho` fai de novo visíbel ao sapoconcho se antes foi agochado. `mostrasapoconcho` pode abreviarse como `msc`.

agochasapoconcho (asc)

-     agochasapoconcho

  `agochasapoconcho` fai invisíbel ao sapoconcho. Isto pode empregarse se o animal non couber no debuxo. `agochasapoconcho` pode abreviarse como `asc`.

### Pode escreber o sapoconcho?

A resposta é: pode. A tartaruga pode escreber, e escreberá calquera cousa que lle mande.

escrebe

-     escrebe X

  O comando `escrebe` ordénalle ao sapoconcho que escreba algo no lenzo. `escrebe` pode tomar textos e números como parámetros. Pode `escrebe`r varios números e cadeas mediante o símbolo +. Aquí vai un exemplo:

      $ano = 2009
      $autor = "Bruno"
      escrebe $autor + " debuxou unha nora en KTurtle no ano" + $ano + " e gustoulle moito!"

letratamaño

-     letratamaño X

  `letratamaño` modifica o tamaño de letra utilizado ao `escreber`. `letratamaño` toma un argumento numérico. O tamaño indícase en píxeles.

### Un comando que escolle ao chou

Hai un comando que saca un número ao chou, chámase `aleatorio` e é moi útil para ter resultados inesperados.

aleatorio (alea)

-     aleatorio X,Y

  `aleatorio` é un comando que toma unha entrada e saca un resultado. Como entrada precisa de dous números, o primeiro (X) é o resultado mínimo, o segundo (Y) o máximo. A saída é un número escollido ao chou que é como mínimo o menor e como máximo o maior. Aquí vai un exemplo:

      repite 500 {
        $x = aleatorio 1,20
        avanza $x
        xiraesquerda 10 - $x
      }

  Mediante o comando `aleatorio` pode introducir algo de caos no programa.

### Introdución de datos e obtención de resultados mediante diálogos

Un diálogo é unha pequena fiestra emerxente que lle dá algo de información ou que lle pide algún dato. &kturtle; ten dous comandos para diálogos, que son: `mostra` e `pergunta`

mostra

-     mostra X

  O comando `mostra` toma un texto como entrada, e mostra un diálogo que contén o texto.

      mostra "Bruno debuxou unha nora en KTurtle no ano 2008 e gustoulle moito!"

pergunta

-     pergunta X

  `pergunta` toma un texto como entrada. Mostra un diálogo que contén o texto, como fai mostra, pero ademais tamén pon un campo de texto no diálogo. Mediante este campo o usuario pode introducir un número ou un texto que pode gardar nun contedor. Por exemplo

      $idade = pergunta "Cantos anos tes?"
      $resultado = 2003 - $idade
      escrebe "En 2003 tiñas " + $resultado + " anos."

  Cando un usuario cancela o diálogo de pergunta, ou non insere nada, o contedor será baleirado.

## Contedores

Os contedores son letras ou palabras que poden ser utilizadas polo programador para gardar un número ou texto. Aos contedores que conteñen un número chámaselles variábeis, e aos que conteñen letras textos. Os contedores identifícanse facilmente polo caracter $ que levan diante do nome.

Os contedores que non están a ser utilizados non conteñen nada. Exemplo:

    escrebe $N

Non escreberá nada e pola contra mostrará unha mensaxe de erro.

### Variábeis: contedores de números

Comecemos cun exemplo:

    $x = 3
    escrebe $x

Na primeira liña a letra `x` é convertida nunha variábel (contedor de números). Como pode ver, a variábel `x` toma o valor 3. Na segunda liña escrébese no lenzo o valor.

Lembre que se quixese escreber un x deberíamos ter feito

    escrebe "x"

Iso foi sinxelo, agora fagámolo algo máis complicado:

    $A = 2004
    $B = 25
    $C = $A + $B

    # o seguinte comando escrebe "2029"
    escrebe $C
    recua 30
    # o seguinte comando escrebe "2004 máis 25"
    escrebe $A + " máis " + $B
    recua 30
    # o seguinte comando escrebe "1979"
    escrebe $A - $B

Nas primeiras dúas liñas dáselles os valores 2004 e 25 ás variábeis `A` e `B`. Na terceira liña a variábel `C` toma o valor `A + B`, que é 2029. O resto do exemplo consiste en 3 comandos `escrebe` con `recua 30` polo medio. Estes `recua` foron postos ahí para garantir que cada cousa fose escrita nunha liña nova. Neste exemplo tamén vemos como as variábeis poden ser empregadas en cálculos matemáticos.

### Contedores que conteñen letras (textos)

No código de programación os textos polo xeral comézanse e termínanse con aspas. Como xa vimos:

    escrebe "Olá programador!"

Estas pezas de texto ordinario son chamadas textos.

Os textos tamén son gardados en contedores como os números, e teñen moitos parecidos coas variábeis. A maior diferenza é que conteñen texto no canto de números. Por este motivo non poden ser utilizados en cálculos matemáticos nen perguntas. Vexamos un exemplo de utilización de textos:

    $saudo = "Olá "
    $nome = pergunta "Dime como te chamas..."
    escrebe $x + $nome + ", como estás?"

Na primeira liña o texto `x` toma o valor de Olá . Na segunda o texto `nome` toma o valor do resultado de `perguntar`. Na terceira liña o programa escrebe no lenzo unha composición de tres textos.

Este programa pídelle que introduza o seu nome. Se escrebe, por exemplo, o nome Paulo, o programa escrebe Olá Paulo, como estás?. Lembre que o signo máis (+) é o único símbolo matemático que pode utilizar cos textos.

## Sabe matemáticas o sapoconcho?

Si, &kturtle; sabe matemáticas. Pode sumar (+), restar (-), multiplicar (*), e dividir (/). Aquí vai un exemplo no que se utilizan estas operacións:

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

Sabe os valores que teñen a, b e c?. Poña atención a que se emprega o símbolo de asinación, `=`.

Se só quer facer un cálculo simples pode facer algo como isto:

    escrebe 2004-12

Agora un exemplo con parénteses:

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

As expresións entre parénteses serán calculadas primeiro. Neste exemplo, calcularase 20-5, logo multiplicarase por 2, dividirase entre 30, e finalmente engádeselle 1, co que dá o resultado 2.

&kturtle; ten capacidades matemáticas avanzadas. Sabe o número `pi`, e funcións trigonométricas como `seno`, `coseno`, `tanxente`, `arcoseno`, `arcocoseno`, `arcotanxente` e as funcións `raiz` e `exp`.

### Deixe que o sapoconcho redondee os números

Se precisa de números enteiros nos cálculos, empregue esta función.

redondea

-     redondea (x)

  `redondea` o número indicado ao enteiro máis próximo.

      escrebe redondea(10.8)
      avanza 20
      escrebe redondea(10.3)
      avanza 20

  Con este código o sapoconcho escreberá os números 11 e 10.

## Facer perguntas, obter respostas...

`se` e `mentres` son controladores da execución que explicaremos na seguinte sección. Nesta utilizaremos o comando `se` para explicar as perguntas.

### Perguntas

Un exemplo simples de pergunta:

    $x = 6
    se $x > 5 {
      escrebe "olá"
    }

Neste exemplo a pergunta é `x > 5`. Se a resposta e isto é "certo" executarase o código entre as chaves. As perguntas son unha parte importantísima da programación e a miúdo son empregadas xunto con controladores de execución, como `se`. Todos os número e variábeis (contedores de números) poden ser comparados uns cos outros en perguntas.

Estas son todas as posíbeis perguntas:

### Tipos de perguntas

`a == b` | é igual a | a resposta é certo se `a` é igual a `b`
`a != b` | é diferente de | a resposta é certo se `a` non é igual a `b`
`a > b` | maior que | a resposta é certo se `a` é maior que `b`
`a < b` | menor que | a resposta é certo se `a` é menor que `b`
`a >= b` | maior ou igual que | a resposta é certo se `a` é maior ou igual a `b`
`a <= b` | menor ou igual que | a resposta é certo se `a` é menor ou igual a `b`

### Encadeamento de perguntas

As palabras de encadeamento de perguntas permítennos xuntar varias perguntas nunha máis elaborada.

    $a = 1
    $b = 5
    se ($a < $b) e ($b == 5) {
      escrebe "Olá"
    }

Neste exemplo a palabra combinadora `e` é empregada para xuntar 2 perguntas (`a < 5`, `b == 5`) nunha. Se un lado do `e` é falso toda a resposta será falso, porque con `e` ambos os dous lados deben ser certo para que a resposta sexa certo. Por favor non se esqueza de empregar os parénteses arredor das perguntas!

Este é un resumo esquemático, a seguir exponse unha explicación detallada:

### Palabras de encadeamento de perguntas

`e` | Ambos os dous lados deben ser "certo" para que a resposta sexa "certo"
`ou` | Se un dos lados é "certo" a resposta será "certo"
`non` | Caso especial: só opera sobre unha pergunta! Muda o estado de "certo" para "falso" ou de "falso" para "certo"

#### e

Cando dúas perguntas son xuntadas mediante un `e`, ambos os dous lados do `e` deben ser "certo" para que o resultado sexa "certo". Por exemplo:

    $a = 1
    $b = 5
    se (($a < 10) e ($b == 5)) e ($a < $b) {
      escrebe "Olá"
    }

Neste exemplo vese unha pergunta combinada dentro de outra pergunta combinada.

#### ou

Se unha das dúas perguntas que están a ser combinadas con `ou` é "certo" o resultado será "certo". Por exemplo:

    $a = 1
    $b = 5
    se (($a < 10) ou ($b == 10)) ou ($a == 0) {
     escrebe "Olá"
    }

Neste exemplo vese unha pergunta combinada dentro de outra pergunta combinada.

#### non

`non` é unha palabra combinadora especial porque só opera sobre unha pergunta á vez. `non` troca o estado de "certo" para "falso" ou viceversa. Por exemplo:

    $a = 1
    $b = 5
    se non (($a < 10) e ($b == 5)) {
      escrebe "Olá"
    }
    noutrocaso
    {
      escrebe "Adeus"
    }

Neste exemplo a pergunta combinada é "certo", pero o `non` troca o resultado para "falso". Deste xeito, escrébese `"Adeus"` no lenzo.

## Control da execución

Os controladores da execución permítenlle, como indica o nome, controlar o fluxo de execución.

Os comandos de control da execución son realzados en letra verde grosa. As chaves utilízanse caseque sempre xunto cos controladores de execución e son realzados en letra negra grosa.

### Facer que o sapoconcho agarde

Se programou algo en &kturtle; xa se terá decatado de que o sapoconcho pode ser moi moi moi rápido cando debuxa. Este comando fai que agarde durante un tempo.

agarda

-     agarda X

  `agarda` fai que o sapoconcho estexa quedo durante X segundos.

      repite 36 {
        avanza 5
        xiradereita 10
        agarda 0.5
      }

  Este código debuxa un círculo, pero o animal agardará medio segundo tras cada paso. Isto dá a impresión dun sapoconcho lento.

### Executar "se"

se

-     se pergunta { ... }

  O código que vai entre as chaves só será executado `se` a resposta á pergunta é certo. Achará máis información acerca das perguntas nas sección de perguntas.

      $x = 6
      se $x > 5 {
        escrebe "x é maior que cinco!"
      }

  Na primeira liña `x` toma o valor 6. Na segunda liña faise a pergunta `x > 5`. Xa que a resposta é certo o controlador de execución `se` permitirá que se execute o código entre as chaves

### Se non, o caso contrario: "noutrocaso"

noutrocaso

-     se pergunta { ... } noutrocaso { ... }

  `noutrocaso` pode empregarse xunto co controlador de execución `se`. O código entre as chaves que seguen a `noutrocaso` só será executado se a resposta á pergunta é falso.

      reinicia
      $x = 4
      se non 5 > $x {
       escrebe "x é maior que cinco!"
      }
      noutrocaso
      {
        escrebe "x é menor que seis!"
      }

  A pergunta é se `x` é maior que 5 (pero do revés ao levar a negación diante). Xa que `x` vale 4 a resposta é falso. Isto significa que se executará o código entre as chaves que seguen a `noutrocaso`.

### O ciclo "mentres"

mentres

-     mentres pergunta { ... }

  O controlador de execución `mentres` seméllase moito a `se`. A diferenza é que `mentres` repite o código entre as chaves até que a resposta á pergunta sexa falso.

      $x = 1
      mentres $x < 5 {
        avanza 10
        agarda 1
        $x = $x + 1
      }

  Na primeira liña `x` toma o valor de 1. Na segunda liña faise a pergunta `x < 5`. Dado que a resposta é certo o controlador de execución `mentres` comeza a executar o código entre as chaves até que a resposta á pergunta sexa falso. Neste caso executarase 4 veces, porque cada vez que se executa a quinta liña `x` aumenta 1.

### O ciclo "repite"

repite

-     repite número { ... }

  O controlador de execucion `repite` seméllase moito a `mentres`. A diferenza é que `repite` executa o código entre as chaves o número dado de veces.

### O ciclo "desde", un ciclo cun contador

desde

-     desde ponto inicial ate ponto final {...}

  O bucle `para` é un bucle con contador, &ie;, mantén por si o reconto.

      desde $x = 1 ate 10 {
        escrebe $x * 7
        avanza 15
      }

  Cada vez que se executa o código entre as chaves o `x` aumenta en 1, até que `x` acada o valor de 10. O código nas chaves escrebe o valor do `x` multiplicado por 7. Cando este programa remate a execución verá a táboa de multiplicar do 7 no lenzo.

  O paso por omisión no bucle é 1, pero pode utilizar outro valor mediante

      desde ponto inicial ate ponto final pasando tamaño do paso { ... }

### Sair dun bucle

sair

-     sair

  Termina de imediato esta volta ao bucle e transfere o control á instrución que vai despois del

### Deter o sapoconcho

fin

-     fin

  Remata a execución do código.

## Cree os seus proprios comandos con define

`define`
é un comando moi especial, porque se utiliza para crear novos comandos. O comando que críe pode tomar entradas e devolver saídas. Vexamos como se cría un comando novo:

    define faiCirculo $x {
      repite 36 {
        avanza $x
        xiraesquerda 10
      }
    }

O novo comando chámase `faiCirculo`. `faiCirculo` toma unha entrada, un número, que indica o tamaño do círculo. `faiCirculo` non devolve nengún resultado. O comando `faiCirculo` pode ser utilizado como un comando normal no resto do código. Vexa este exemplo:

    define faiCirculo $X {
      repite 36 {
        avanza $X
        xiraesquerda 10
      }
    }
    vai 200,200
    faiCirculo 20

    vai 300,300
    faiCirculo 40

No seguinte exemplo, críase un comando que devolve un valor.

    reinicia

    define multiplicarseUnMesmo $n {
      $resultado = $n * $n
      devolve $resultado
    }
    $i = pergunta "Indique un número e prema en Aceitar"
    escrebe $i + " multiplicado por si mesmo é: " + multiplicarseUnMesmo $i

Neste exemplo críase un comando novo chamado `multiplicarseUnMesmo`. A entrada deste comando é multiplicada por si mesma e logo devólvese o resultado, mediante o comando `devolve`. O comando `devolve` é a maneira de obter un valor como resultado das funcións que críe.

Os comandos poden ter máis dunha entrada. No seguinte exemplo, críase un comando que debuxa un rectángulo.

    define debuxaRectangulo $X, $Y {
      avanza $Y
      xiradereita 90
      avanza $X
      xiradereita 90
      avanza $Y
      xiradereita 90
      avanza $X
      xiradereita 90
    }

Agora pode ordenar `debuxaRectangulo 50,100` e o sapoconcho debuxará no lenzo un rectángulo.