# Referencia do programador de &turtlescript;

Este é o manual do &turtlescript; de &kturtle;. Na primeira sección vense algúns aspectos da gramática dos programas de &turtlescript;. A segunda sección trata das operacións matemáticas, operacións lóxicas (certo/falso) e operacións de comparación. A terceira sección é unha lista de todas as ordes explicándoas unha por unha. A cuarta sección explica como asignar valores a variábeis. Na quinta sección explícase como ordear a execución das ordes con sentenzas de control da execución e finalmente na sexta como crear as tuas proprias ordes con define.

## A gramática de &turtlescript;

Como calquera linguaxe, &turtlescript; ten diferentes tipos de palabras e símbolos. En galego distinguimos verbos (como «camiñar» ou «falar») e nomes (como «tartaruga» ou «bicicleta»), e úsanse para cousas diferentes. &turtlescript; é unha linguaxe de programación que se usa para dicirlle á &kturtle; o que ten que facer.

Nesta sección explícase brevemente que son algúns tipos de palabras de &turtlescript;. Explicaremos os comentarios, ordes e os tres tipos diferentes de literais: números, textos e valores lóxicos (certo/falso).

### Comentarios

Un programa consiste en instrucións que se executan cando se executa o programa e en comentarios. Os comentarios non se executan, &kturtle; ignóraos; somente están aí para que outros programadores entendan mellor o que fai o programa. En &turtlescript; considérase comentario todo o que segue a un símbolo `#`. Por exemplo este programa que non fai ren:

    #este programa non fai ren, só é un comentario!

É pouco útil pero explica moi ben o asunto.

Os comentarios son moi útiles cando o programa empeza a ser algo complexo. Poden axudar a outros programadores. No seguinte programa podes ver comentarios usados xunto coa orde escribe.

    # este programa fíxoo Cies Breijs.
    escribe "este texto hase escribir no lenzo"
    # a liña anterior non é un comentario, a seguinte si:
    # escribe "este texto non se ha escribir!"

A primeira liña describe o programa. &kturtle; executa a segunda e imprime `este texto hase escribir no lenzo` no lenzo. A terceira liña é un comentario, e a cuarta liña é un comentario que contén unha peza de &turtlescript;, se eliminásemos o símbolo `#` desta liña &kturtle; había executar a orde. Os programadores din: a orde escribe na cuarta liña está «comentada».

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

### Ordes

Mediante as ordes díslle á tartaruga de &kturtle; que faga algo. Algunhas ordes precisan datos, outras producen algunha saída.

    # avanza é unha orde que precisa de datos, neste caso o número 100:
    avanza 100

A primeira liña é un comentario. A segunda liña contén a orde `avanza` e o número `100`. O número non é parte da orde, senón que se considera «entrada» del.

Algunhas ordes como &eg; `vai` precisan de máis dun dato de entrada. Cando son varios valores hai que separalos mediente `,` (comas).

Para coñecer máis detalles sobre todas as ordes permitidas por &kturtle; vaia aquí. As ordes de serie reálzanse en azul escuro

### Números

Posibelmente xa saiba bastante sobre os números. A maneira de utilizar os números en &kturtle; non é moi distinta da oral, nin 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`. Úsase o `.` (punto) como separador decimal.

Os números poden ser utilizados en operacións matemáticas e comparacións. Tamén poden gardarse en variábeis. Os números reálzanse en roxo.

### Textos

Primeiro un exemplo:

    escribe "Olá, son un texto."

Neste exemplo `escribe` é unha orde na 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 variábeis, igual que os números, pero a diferenza destes non poden usarse en operacións matemáticas nin en comparacións. Os textos reálzanse en vermello.

### Valores lóxicos (certo/falso)

Só hai dous valores lóxicos: `certo`
e `falso`
. Algunhas veces tamén se lles chama: verdadeiro e falso, si e non, un e cero. Pero en &turtlescript; sempre se lles chama `certo` e `falso`. Bótalle unha olla da e este retallo de &turtlescript;:

    $a = certo

. Se miran no inspector verás que a variábel `$a` ten o valor `certo` e é de tipo lóxico.

A miúdo os valores lóxicos son o resultado dunha operación de comparación, como no seguinte retallo de &turtlescript;:

    $resposta = 10 > 3

A variábel `$resposta` ten o valor `certo` porque `10` é maior que `3`.

Os valores lóxicos, `certo` e `falso`, son realzados en roxo escuro.

## Operacións matemáticas, lóxicas e de comparación

O título desta sección pode parecer difícil, pero non o é tanto como parece.

### Operacións matemáticas

Estes son os símbolos matemáticos básicos: suma (`+`), resta (`-`), multiplicación (`*`), división (`/`) e potencia(`^` ).

Este é un exemplo das operacións matemáticas que podes usar no &turtlescript;:

    $suma      = 1 + 1
    $resta      = 20 - 5
    $multiplica= 15*2
    $divide    = 30 / 30
    $repite    = 2 ^ 2

Os resultados das operacións matemáticas asígnanse a variábeis. Mediante o inspector pode consultalas.

Se só ques facer un cálculo simples podes facer algo como isto:

    escribe 2010-12

Agora un exemplo con parénteses:

    escribe ( (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. Os parénteses tamén se poden usar noutros casos.

&kturtle; tamén ten funcionalidades matemáticas máis avanzadas entre as súas ordes. Bótalle un ollo ás seguintes ordes, pero ten en conta que son operacións avnzadas: redondea, aleatorio, raiz, pi, seno, coseno, tanxente, arcoseno, arcocoseno, arcotanxente.

### Operacións lóxicas (certo/falso)

Mentres que as operacións matemáticas son principalmente para números, as lóxicas sono para valores lóxicos (`certo` e `falso`). Só hai tres operacións lóxicas: `e`
, `ou`
, e `non`
. Este retallo de &turtlescript; mostra como usalos:

     $e_1_1 = certo e certo    # -> certo
    $e_1_0 = certo e falso              # -> falso
    $e_0_1 = falso e falso                        # -> falso
    $e_0_0 = falso e falso                        # -> falso

    $ou_1_1 = certo ou certo # -> certo
    $ou_1_0 = certo ou falso           # -> certo
    $ou_0_1 = falso ou certo           # -> certo
    $ou_0_0 = falso ou falso                     # -> falso
    n$non_1 = non certo   # -> falso
    $non_0 = non falso             # -> certo

Usando o inspector pode consultar os valores, aínda que poñemos os resultados nos comentarios ao final das liñas. `e` dá `certo` só se ambos os dous lados son `certo`. `ou` dá `certo` se algún dos lados é `certo`. E `non` converte un `certo` nun `falso` e un `falso` nun `certo`.

A operacións lóxicas reálzanse en rosa.

#### Algúns exemplos máis avanzados

Considera o seguinte exemplo con `e`:

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

Neste retallo de &turtlescript; o resultado de tres operacións de comparación xúntase mediante operacións `e`. Isto significa que os tres deben dar «certo» para que se escriba «Olá».

Un exemplo con `ou`:

    %n = 1
    se ($n < 10) ou ($n == 2) {
      escribe "Olá"
    }

Neste retallo de &turtlescript; o lado da esquerda do `ou` avalíase como «certo» e o da dereira a «falso». Xa que un dos lados do operador `ou` é «certo», o operador `ou` avalíase como «certo», en consecuencia escríbese «Olá».

E finalmente un exemplo con `non`, que troca para «certo» por «falso» e «falso» por «certo». Mira:

    $n = 1
    se non ($n == 3) {
      escribe "Olá"
    } senon {
      escribe "non olá ;-)"
    }

### Operacións de comparación

Considera esa sinxela comparación:

    $resposta = 10 > 3

Aquí compárase`10` con `3` mediante o operador «maior que». O resultado desta comparación, o valor lóxico `certo` gárdase na variábel `$resposta`.

Os números e as variábeis (que conteñen números) poden compararse entre si mediante operacións de comparación.

Este son todas as operacións de comparación:

#### Tipos de preguntas

`$A == $B` | é igual a | a resposta é certo se `$A` conté o mesmo valor que `$B`
`$A != $B` | é diferente de | a resposta é certo se `$A` non é igual que `$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 que ou igual a `$B`
`$A <= $B` | menor ou igual que | a resposta é certo se `$A` é menor que ou igual a `$B`

Lembra que $A e $B teñen que ser números ou variábeis que conteñan númeors.

## Ordes

Mediante as ordes pode dicirlle ao sapoconcho de &kturtle; que faga algo. Algunhas ordes precisan de parámetros, outras xeran un resultado. Nesta sección explicamos todas as ordes que veñen de serie no &kturtle;. Ademáis, mediante a orde define pode crear as súas propias ordes. As ordes de serie que se explican aquí reálzanse en azul escuro.

### Mover o sapoconcho

Hai varias ordes que moven o sapoconcho pola pantalla.

avanza (av)

      avanza X

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

retrocede (re)

      retrocede X

  `retrocede` move o sapoconcho cara atrás X píxeles. Se o lapis está pousado deixará un rastro. `retrocede` pode abreviarse 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`.

obtendireccion

      obtendireccion

  `obtendireccion` devolve a dirección na que mira a tartaruga como unha cantidade de graus contados desde arriba.

vaiamedio

      vaimedio

  `vaiamedio` 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 da beira esquerda 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. `vaix` pode abreviarse com `vx`.

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. `vaiy` pode abreviarse como `vy`.

Cando se utilizan as ordes `vai`, `vaix`, `vaiy` e `vaimedio` o sapoconcho non debuxa a liña, con independencia de que o lapis estea erguido ou pousado.

### Onde está o sapoconcho?

Hai dúas ordes que din a posición do sapoconcho na pantalla.

coordenadaX

  `coordenadax` devolve a cantidade de píxeles que hai desde a esquerda do lenzo ata a posición do sapoconcho.

coordenaday

  `coordenaday` devolve a cantidade de píxeles que hai do cume do lenzo ata a posición do sapoconcho.

### O sapoconcho ten un lapis

O sapoconcho ten un lapis que debuxa unha liña a medida que se move o animal. Hai unhas poucas ordes que controlan este lapis. Nesta sección explicarémolas.

subelapis (sl)

      subelapis

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

baixalapis (bl)

      baixalapis

  `baixalapis` pousa o lapis no lenzo. Cando o lapis está baixado debúxanse liñas cando se move o sapoconcho. Consulta 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`.

### Ordes para controlar o lenzo

Hai varias ordes que controlan o lenzo.

tamañolenzo (tlz)

      tamañolenzo X,Y

  Mediante a orde `tamañolenzo` pode axustar o tamaño da área. Toma X e Y como entradas, onde X é a nova anchura do lenzo en píxeles e Y é a nova altura 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`.

### Ordes para limpar

Hai dúas ordes para limpar o lenzo cando o emborrona.

borra (br)

      borra

  Con `borra` pode limpar todos os debuxos do lenzo. As demais cousas quedan: a posición, dirección e visibilidade do sapoconcho, e a cor e o tamaño do lenzo.

reinicia

      reinicia

  `reinicia` limpa máis a fondo do que o fai a orde `borra`. Despois de executar unha orde `reinicia` todo volve 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 computador. O noso animaliño tamén é un sprite. Para saber máis sobre isto, consulte a entrada sprites no glosario.

A continuación atopará un resumo completo de todas as ordes 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á cambialo por un deseño seu]

mostrasprite (ms)

      mostrasprite

  `mostrasprite` fai visíbel o sapoconcho se antes se agochou. `mostrasprite` pode abreviarse como `ms`.

agochasprite (as)

      agochasprite

  `agochasprite` agocha o sapoconcho. Isto pode empregarse se o animal non couber no debuxo. `agochasprite` pode abreviarse como `as`.

### Pode escribir o sapoconcho?

A resposta é: pode. A tartaruga pode escribir, e escribirá case calquera cousa que lle ordene.

escribe

      escribe X

  A orde `escribe` ordéalle ao sapoconcho que escriba algo no lenzo. `escribe` pode tomar textos e números como parámetros. Pode `escribe`r varios números e cadeas mediante o símbolo +. Aquí vai un exemplo:

      $ano = 2021
      $autor = "Aroa"
      escribe $autor + " debuxou unha nora en KTurtle no ano" + $ano + " e gustoulle moito!"

tamañoletra

      tamañoletra X

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

### Ordes matemáticas

As seguintes ordes son as máis avanzadas de &kturtle; para matemáticas.

redondea

      redondea X

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

      escribe redondea 10.8
      avanza 20
      escribe redondea 10.3
      avanza 20

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

aleatorio (alea)

      aleatorio X,Y

  `aleatorio` é unha orde 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 a orde `aleatorio` pode introducir algo de caos no programa.

mod

      mod X,Y

  `mod` devolve o resto da división do primeiro número entre o segundo.

raiz

      raiz X

  A orde `raiz` devolve a raíz cuadrada do argumento.

pi

      pi

  Esta orde devolve a constante Pi, `3.14159`.

seno
, coseno
, tanxente

      seno X
      coseno X
      tanxente X

  Estas tres ordes representan as famosas funcións trigonométricas `seno`, `coseno` e `tanxente`. O argumento destas tres ordes, X, é un número.

arcoseno
, arcocoseno
, arcotanxente

      aroceion X
      arcocoseno X
      arcotanxente X

  Estas ordes son as funcións inversar deseno, coseno e tanxente. O argumento, X, é un número.

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

Un diálogo é unha pequena xanela emerxente que lle fornece algo de información ou que lle pide algún dato. &kturtle; ten dúas ordes para diálogos, que son: `mostra` e `pregunta`

mostra

      mostra X

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

      mostra "Brandán debuxou unha nora en KTurtle no ano 2021 e gustoulle moito!"

pregunta

      pregunta X

  `pregunta` 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 nunha variábel ou pasar como argumento a unha orde. Por exemplo

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

  Cando un usuario cancela o diálogo de pergunta, ou non insere nada, a variábel estará baleira.

## Asignación de variábeis

Primeiro vexamos o que son as variábeis, logo como asignarlles valores.

As variábeis son palabras que comezan cun $. No editor reálzanse en morado.

As variábeis poden contar calquera número, texto ou valor lóxico (certo/falso. Dáselles contido mediante a asignación, `=`. Terá ese valor até que o programa remate a execución ou até que se lle asigne outro valor.

Unha vez asignadas, pode usar as variábeis no canto do seu valor. Por exemplo no seguinte retallo de &turtlescript;

    $x = 10
    $x = $x / 3
    escribe $x

Primeiro a variábel `$x` convértese no `10`. Logo `$x` convértese no valore resultante de dividirse entre `3` — o que significa que se reasigna a `$x` o resultado de `10/3`. Finalmente, escríbese `$x`. Nas liñas segunda e terceira podes ver que `$x` é usada como se ela fose o que contén.

Para poder usar unha variábel ten que asignarse. Exemplo:

    escribe $n

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

Vexamos o seguinte retallo de &turtlescript;:

    $a = 2004
    $b = 25

    # a seguinte orde escribe "2029"
    escribe $a + $b
    retrocede 30
    # a seguinte orde escribe "2004 máis 25 é igual a 2029"
    escribe $a + " máis " + $b " é igual a " ($a + $b)

Nas primeiras dúas liñas dáselles os valores 2004 e 25 ás variábeis `$a` e `$b`. Despois execútanse dúas ordes `escribe` cunha `retrocede 30` no medio. Os comentarios antes de cada orde `escribe` explícan o que fan. A orde `retrocede` foi posta aí para garantir que cada cousa se escriba nunha liña nova. Neste exemplo tamén vemos como as variábeis poden empregarse como se fosen o que conteñen, pode usalas con calquera operación ou usalas como parámetros das ordes.

Outro exemplo máis:

    $nome = pregunta "Como te chamas?"
    escribe "Olá " + $nome + "! Verás que sinxelo é aprender a programar..."

Abondo claro. e novo vese o uso da variábel `$nome` tratada como un texto.

O inspector é de moita axuda cando se usan variábeis. Móstra o contido de todas as variábeis que se están a usar.

## Control da execución

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

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

### Facer que o sapoconcho agarde

Se programou algo en &kturtle; xa se decataría de que o sapoconcho pode ser moi moi moi rápido cando debuxa. Esta orde fai que agarde durante un tempo.

agarda

      agarda X

  `agarda` fai que o sapoconcho estea 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 valor lóxico { … }

  O código que vai entre as chaves só será executado `se` o predicado é certo.

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

  Na primeira liña `$x` vale 6. Na segunda liña úsase unha operación de comparación para avaliar `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, ou en caso contrario: "senon"

senon

      se boolean { ... } senon { ... }

  `senon` pode empregarse xunto ccontrolador de execución `se`. O código entre as chaves que seguen a `senon` só se executará se o predicado é falso.

      reinicia
      $x = 4
      se $x > 5 {
       escribe "x é maior que cinco!"
      }
      senon
      {
        escribe "x é menor que seis!"
      }

  A comparación avalia a expresión `$x > 5`. Xa que 4 no o é a resposta é falso. Isto implica que se executará o código entre as chaves que seguen a `senon`.

### O ciclo «mentres»

mentres

      mentres valor lóxico { … }

  O controlador de execución `mentres` seméllase moito a `se`. A diferenza é que `mentres` repite o código entre as chaves ate que o valor lóxico sexa falso.

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

  Na primeira liña `$x` toma o valor 1. Na segunda liña avalíase `$x < 5`. Dado que a resposta é certo o controlador de execución `mentres` comeza a executar o código entre as chaves ata que `$x < 5` sexa falso. Neste caso executarase 4 veces, porque cada vez que se executa a quinta liña `$x` increméntase.

### 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 variábel = número ate número { ... }

  O bucle `desde` é un bucle con contador, &ie;, mantén por si o reconto. O primeiro número é o valor da variábel na primeira volta. En cada ciclo a variábel increméntase até que se acade o segundo número.

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

  Cada vez que se executa o código entre as chaves o `$x` aumenta en 1, ate que `$x` acada o valor de 10. O código nas chaves escribe 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 predeterminado no bucle é 1, pero pode utilizar outro valor mediante

      desde variábel = número ate número pasando número { ... }

### Saír dun bucle

sair

      sair

  Termina de inmediato esta volta ao bucle e transfere o control á instrucción que vai despois del.

### Detén a execución do programa

fin

      fin

  Remata a execución do programa.

### Comprobar asercións durante a execución

aserto

      aserto predicado

  Pode usarse para razonar acerca do programa ou comprobar que as entradas sexan correctas.

      $en = pregunta "En que ano naciches?"
      # o ano debe ser positivo
      aserto $en
      > 0

## Cree as súas propios ordes con define

`define`
é unha orde moi especial, porque se utiliza para crear novas ordes. A orde que cree pode tomar entradas e devolver resultados. Vexamos como se crea unha orde nova:

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

O nova orde chámase `faiCirculo`. `faiCirculo` toma unha entrada, un número que indica o tamaño do círculo. `faiCirculo` non devolve nengún resultado. A orde `faiCirculo` pode ser utilizado como unha orde 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 unha orde que
un valor.

    define factorial $x {
      $r = 1
      deste $i = 1 ate $x  {
        $r = $r * $i
      }
      devolve $r
    }

    escribe factorial 5

Neste exemplo críase unha orde nova chamada `factorial`. Se entrada desta orde é`5` a saída será `5*4*3*2*1`. Ao usar `devolve` especifícase o valor devolto e a execución continúase.

As ordes poden ter máis dun parámetro. No seguinte exemplo, créase unha orde 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.