# &turtlescript;'i käskude seletused

Alljärgnev on &kturtle;'i &turtlescript;i seletus. Peatüki esimeses osas tutvustame &turtlescript;i programmide grammatika mõningaid külgi. Teises osas on juttu eranditult matemaatilistest tehetest, tõeväärtustehetest ja võrdlustehetest. Kolmas osa kujutab endast hiiglaslikku kõigi käskude seletust. Neljandas osas selgitatakse, kuidas omistada väärtusi muutujatele. Lõpuks seletame viiendas osas, kuidas korraldada käskude täitmist täitmise kontrollimise lausetega, ning kuuendas osas, kuidas luua omaenda käske käsuga learn.

## &turtlescript;i grammatika

Nagu igas keeles, on ka &turtlescript;il omad sõnad ja sümbolid. Tavalises keeles eristatakse näiteks tegusõnu ("käima", "laulma") ja nimisõnu ("õde", "maja"), mida kasutatakse eri eesmärgil. &turtlescript; on programmeerimiskeel, mida kasutatakse &kturtle;'i juhendamiseks, mida ette võtta.

Käesolevas osas selgitatakse lühidalt &turtlescript;i sõnade ja sümbolite tüüpe. Me tutvustame kommentaare, käske ja kolme eri laadi literaale: arvud, stringid ja tõeväärtused (tõene/väär).

### Kommentaarid

Programm koosneb instruktsioonidest, mis täidetakse programmi töötamisel, ja niinimetatud kommentaaridest. Kommentaare ei täideta, &kturtle; lihtsalt eirab neid töötamise ajal. Kommentaarid on mõeldud teistele programmeerijatele, et nad saaksid paremini programmist aru. Kõik, mis järgneb sümbolile `#`, on &turtlescript;i seisukohalt kommentaar. Näiteks see pisike programm ei tee midagi:

    # see väike programm ei tee midagi, see ongi ainult kommentaar!

See on vahest mõttetu, aga selgitab kenasti asja olemust.

Kommentaarid on väga kasulikud, kui programm on vähegi keerukam. Need on suureks abiks teistele programmeerijatele. Järgmises programmis kasutatakse kommentaare koos käsuga print.

    # selle programmi tegi Cies Breijs.
    print "seda teksti näidatakse lõuendil"
    # eelmine rida ei olnud kommenaar, aga järgmine rida on:
    # print "seda teksti ei näidata!"

Programm esimene rida kirjeldab programmi. Teise rea &kturtle; täidab ning näitab lõuendil teksti `seda teksti näidatakse lõuendil`. Kolmas rida on kommentaar. Neljas rida on samuti kommentaar, mis aga sisaldab &turtlescript;i, nii et kui sümbol `#` neljanda rea eest eemaldada, täidab &kturtle; ka selle näitamiskäsu. Programmeerijate kõnepruugis on neljanda rea näitamiskäsk "välja kommenteeritud".

Kommenteeritud read on redaktoris esile tõstetud helehalli värviga.

### Käsud

Käskudega antakse kilpkonnale ehk &kturtle;'ile korraldus midagi teha. Mõned käsud vajavad sisendit, teised annavad väljundit.

    # forward on käsk, mis vajab sisendit, antud juhul arvu 100:
    forward 100

Esimene rida on kommentaar. Teine rida sisaldab käsku `forward` ja arvu `100`. Arv ei ole käsu osa, seda käsitletakse käsu "sisendina".

Täpsemalt kirjeldatakse kõiki käske, mida &kturtle; toetab, siin. Sisseehitatud käsud on esile tõstetud tumesinise värviga.

### Arvud

Arvatavasti oled juba koolis õppinud, mis asjad on arvud või mingil muul moel osanud selle välja uurida. &kturtle; kasutab arve üsna sarnaselt sellele, kuidas kasutatakse neid matemaatikas või kas või tavalises kõnepruugis.

Me kasutamine niinimetatud naturaalarve: `0`, `1`, `2`, `3`, `4`, `5` jne. Samuti negatiivseid arve: `-1`, `-2`, `-3` jne. Aga ka murdarve, näiteks: `0.1`, `3,14`, `33,3333`, `-5,05`, `-1,0`.

Arve saab pruukida matemaatilistes tehetes ja võrdlustehetes. Neid saab lisada ka salvestada muutujatesse. Arvud on esile tõstetud tumepunase värviga.

### Stringid

Kõigepealt näide:

    print "Hei, mina olen string."

Selles näites on `print` käsk, `"Hei, mina olen string."` aga string. Stringide alguses ja lõpus seisab `"`, mille järgi &kturtle; tunneb ära, et tegemist on stringiga.

Stringid võivad esineda muutujates nagu arvudki. Aga erinevalt arvudest ei saa stringe kasutada matemaatilistes tehetes ega võrdlustehetes. Stringid on esiletõstetud punase värviga.

### Tõeväärtused (tõene/väär)

Tõeväärtusi on ainult kaks: `tõene` ja `väär`. Mõnikord kasutatakse nende kohta ka muid nimetusi: sees ja väljas, jah ja ei, üks ja null. Kuid &turtlescript;is on nad alati `tõene` ja `väär`. Vaatame killukest &turtlescript;i:

    $a = true

Kui vaadata inspektorit, näeb, et muutuja `$a` väärtuseks on määratud `tõene` ja see on tõeväärtus.

Tõeväärtused on sageli võrdlustehte tulemus, nagu järgmises &turtlescript;i killukeses:

    $answer = 10 > 3

Muutuja `$answer` väärtuseks on määratud `tõene`, sest `10` on suurem kui `3`.

Tõeväärtused `tõene` ja `väär` on esile tõstetud tumepunase värviga.

## Matemaatika-, tõeväärtus- ja võrdlustehted

Selle osa pealkiri võib tunduda raskepärasena, aga tegelikult pole siin midagi väga keerulist.

### Matemaatilised tehted

Need on põhilised matemaatikasümbolid: liitmine (`+`), lahutamine (`-`), korrutamine (`*`), jagamine (`/`) ja astendamine (`^`).

Väike näide matemaatikatehetest &turtlescript;is:

    $add      = 1 + 1
    $subtract = 20 - 5
    $multiply = 15 * 2
    $divide   = 30 / 30
    $power    = 2 ^ 2

Matemaatikatehete tulemused omistatakse eri muutujatele. Väärtusi näeb inspektori abil.

Kui soovid väga lihtsat tehet teha, siis see käib umbes nii:

    print 2010-12

Ja nüüd näide sulgudega:

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

Sulgudes olevad tehted sooritatakse esimestena. Antud näites arvutatakse 20-5, siis korrutatakse 2-ga, jagatakse 30-ga ning seejärel liidetakse 1 (tulemuseks on 2). Sulge võib kasutada ka muudel juhtudel.

&kturtle; pakub käskudes teistegi matemaatiliste võimaluste kasutamist. Uuri näiteks järgmisi käske (kuid arvesta, et tegemist on keerukamate tehetega): round, random, sqrt , pi, sin, cos, tan, arcsin, arccos, arctan.

### Tõeväärtustehted

Kui matemaatilised tehted on mõeldud eelkõige arvudele, siis tõeväärtustehteid tehakse tõeväärtustega (`tõene` ja `väär`) Tõeväärtustehteid on ainult kolm, nimelt `and`, `or` ja `not`. Järgnev &turtlescript;i killuke seletab nende kasutamist:

    $and_1_1 = true and true    # -> true
    $and_1_0 = true and false   # -> false
    $and_0_1 = false and true   # -> false
    $and_0_0 = false and false  # -> false

    $or_1_1 = true or true    # -> true
    $or_1_0 = true or false   # -> true
    $or_0_1 = false or true   # -> true
    $or_0_0 = false or false  # -> false

    $not_1 = not true   # -> false
    $not_0 = not false  # -> true

Inspektoris näeb ka väärtusi, kuid me andsime tulemused ka lühikommentaarina ridade lõpus. `and` on `tõene` ainult siis, kui mõlemad pooled on `tõesed`. `or` on `tõene` siis, kui üks pooltest on `tõene`. `not` aga muudab `tõese` `vääraks` ja `väära` `tõeseks`.

Tõeväärtustehted on esile tõstetud roosa värviga.

#### Mõned keerukamad näited

Üks näide tehte `and` kohta:

    $a = 1
    $b = 5
    if (($a < 10) and ($b == 5)) and ($a < $b) {
      print "hello"
    }

Selles &turtlescript;i killukeses ühendatakse kolm võrdlustehet tehte `and` abil. See tähendab, et kõik kolm peavad olema "tõesed", et näidataks teksti "hello".

Näide tehtega `or`:

    $n = 1
    if ($n < 10) or ($n == 2) {
      print "hello"
    }

Selles &turtlescript;i killukeses on `or` vasak pool "tõene", parem pool aga "väär". Et `or` üks pool on siiski "tõene", on ka tehte `or` tulemus "tõene" ning järelikult näidatakse teksti "hello".

Lõpuks ka näide tehtega `not`, mis muudab "tõese" "vääraks" ja "väära" "tõeseks":

    $n = 1
    if not ($n == 3) {
      print "hello"
    } else {
      print "not hello ;-)"
    }

### Võrdlustehted

Vaatleme lihtsat võrdlust:

    $answer = 10 > 3

Siin võrreldakse arvu `10` arvuga `3` "suurem kui" tehtega. Võrdluse tulemus, tõeväärtus `tõene` salvestatakse muutujasse `$answer`.

Võrdlustehetega saab omavahel võrrelda kõiki arve ja muutujaid (mis sisaldavad arve).

Toome ära kõik võimalikud võrdlustehted:

#### Küsimuste tüübid

`$A == $B` | võrdub | vastus on tõene, kui `$A` võrdub `$B`
`$A != $B` | ei võrdu | vastus on tõene, kui `$A` ei võrdu `$B`-ga
`$A > $B` | suurem kui | vastus on tõene, kui `$A` on suurem kui `$B`
`$A < $B` | väiksem kui | vastus on tõene, kui `$A` on väiksem kui `$B`
`$A >= $B` | suurem kui või võrdne | vastus on tõene, kui `$A` on suurem kui või võrdub `$B`-ga
`$A <= $B` | väiksem kui või võrdne | vastus on tõene, kui `$A` on väiksem kui või võrdub `$B`-ga

Palun arvesta, et $A ja $B peavad olema arvud või muutujad, mis sisaldavad arve.

## Käsud

Just käskudega saab panna kilpkonna või &kturtle;'i midagi tegema. Osa käske eeldab sisendit, osa annab väljundi. Selles osas kirjeldame kõiki &kturtle;'i sisseehitatud käske. Lisaks saab oma käske luua käsuga learn. Käsitletavad sisseehitatud käsud on esile tõstetud tumesinise värviga.

### Kilpkonna liigutamine

Kilpkonna saab lõuendil liigutada mitme käsuga.

forward (fw)

      forward X

  `forward` paneb kilpkonna otse edasi liikuma X piksli võrra. Kui pliiats on sees, jätab kilpkonna ka jälje maha. `forward` asemel võib kasutada lühendit `fw`.

backward (bw)

      backward X

  `backward` paneb kilpkonna otse tagasi liikuma X piksli võrra. Kui pliiats on sees, jätab kilpkonna ka jälje maha. `backward` asemel võib kasutada lühendit `bw`.

turnleft (tl)

      turnleft X

  `turnleft` paneb kilpkonna X kraadi võrra vasakule pöörama. `turnleft` asemel võib kasutada lühendit `tl`.

turnright (tr)

      turnright X

  `turnright` paneb kilpkonna X kraadi võrra paremale pöörama. `turnright` asemel võib kasutada lühendit `tr`.

direction (dir)

      direction X

  `direction` määrab kilpkonna suunaks X kraadi arvestades nullist, see ei ole seotud kilpkonna varasema suunaga. `direction` asemel võib kasutada lühendit `dir`.

center

      center

  `center` sunnib kilpkonna liikuma lõuendi keskpunkti.

go

      go X,Y

  `go` paneb kilpkonna liikuma lõuendi konkreetsesse punkti. See asub X piksli kaugusel lõuendi vasakust servast ja Y piksli kaugusel lõuendi ülaservast.

gox

      gox X

  `gox` paneb kilpkonna samal kõrgusel liikuma X piksli kaugusele lõuendi vasakust servast.

goy

      goy Y

  `goy` paneb kilpkonna samal laiusel (kaugusel vasakust servast) liikuma Y piksli kaugusele lõuendi ülaservast.

Käskudega `go`, `gox`, `goy` ja `center` ei joonista kilpkonn joont, olgu pliiats üleval või all.

### Kus on kilpkonn?

Kilpkonna asukohta lõuendil saab teada kahe käsuga.

getx

  `getx` tagastab pikslite arvu lõuendi vasakust servast kilpkonna asukohani.

gety

  `gety` tagastab pikslite arvu lõuendi ülemisest servast kilpkonna asukohani.

### Kilpkonn pliiatsiga

Kilpkonnal on pliiats, millega ta liikudes joont veab. Pliiatsit saab juhtida mitme käsuga, mida siin tutvustamegi.

penup (pu)

      penup

  `penup` tõstab pliiatsi lõuendilt ja kuni see on üleval, ei tõmba kilpkonn liikudes ühtki joont. Vaata ka `pendown`. `penup` asemel võib kasutada lühendit `pu`.

pendown (pd)

      pendown

  `pendown` surub pliiatsi lõuendi vastu ja kuni see on all, tõmbab kilpkonn liikudes joone. Vaata ka `penup`. `pendown` asemel võib kasutada ka lühendit `pd`.

penwidth (pw)

      penwidth X

  `penwidth` määrab pliiatsi tõmmatava joone laiuseks X pikslit. `penwidth` asemel võib kasutada ka lühendit `pw`.

pencolor (pc)

      pencolor R,G,B

  `pencolor` määrab pliitsi tõmmatava joone värvi. `pencolor` tahab saada sisendina RGB värvikoodi. `pencolor` asemel võib kasutada ka lühendit `pc`.

### Lõuendiga seotud käsud

Lõuendi omadusi saab muuta mitme käsuga.

canvassize (cs)

      canvassize X,Y

  Käsk `canvassize` määrab lõuendi suuruse. Käsu sisendiks on X ja Y, kus X on uue lõuendi laius pikslites ja Y uue lõuendi kõrgus samuti pikslites. `canvassize` asemel võib kasutada lühendit `cs`.

canvascolor (cc)

      canvascolor R,G,B

  Käsk `canvascolor` määrab lõuendi värvi. `canvascolor` tahab saada sisendina RGB värvikoodi. `canvascolor` asemel võib kasutada ka lühendit `cc`.

### Puhastamiskäsud

Kahe käsuga saab lõuendi puhastada sellest, mida sa sinna oled valmis meisterdanud.

clear (ccl)

      clear

  Käsk `clear` puhastab lõuendilt kogu joonistatu. Muud asjad jäävad püsima: kilpkonna asukoht ja nurk, lõuendivärv, kilpkonna nähaolek ja lõuendi suurus.

reset

      reset

  Käsk `reset` puhastab palju rohkem asju kui `clear`. Pärast käsku `reset` on kõik taas selline, nagu &kturtle;'i käivitamisel: kilpkonn on lõuendi keskel, lõuendi värv on valge, kilpkonn hakkab liikudes vedama musta joont ja lõuendi suurus on 400 x 400 pikslit.

### Kilpkonn on sprait

Vaevalt et paljud teavad, mis õieti on sprait, nii et ütleme siis saladuse välja: sprait on väike pilt, mida saab ekraanil liigutada. Täpsemalt vaata sõnastikust mõiste sprait kirjeldust. See tähendab, et meie kilpkonn on sprait!

Toome siin ära kõik käsud, mida saab spraidi puhul kasutada.

[&kturtle;'i praegune versioon toetab spraidina ainult kilpkonna kasutamist. Aga tulevikus võib olla vägagi võimalik, et võid kilpkonna oma soovi kohaselt millegi muuga asendada.]

spriteshow (ss)

      spriteshow

  Käsk `spriteshow` muudab kilpkonna uuesti nähtavaks pärast tema peitmist. `spriteshow` asemel võib kasutada ka lühendit `ss`.

spritehide (sh)

      spritehide

  `spritehide` peidab kilpkonna. Seda on mõtet kasutada siis, kui kilpkonn kohe kuidagi ei taha sinu joonistusele sobida. `spritehide` asemel võib kasutada ka lühendit `sh`.

### Kas kilpkonn oskab ka kirjutada?

Õige vastus: jah, muidugi. Kilpkonn võib kirjutada küll, aga mõistagi pead sina talle ütlema, mida kirjutada.

print

      print X

  `print` annab kilpkonnale käsu midagi lõuendile kirjutada. `print` sisendiks võivad olla nii numbrid kui stringid. Sümbolit + kasutades saab käsuga `print` lasta kirjutada mitmesuguseid numbreid ja stringe. Toome siin väikese näite:

      $year = 2003
      $author = "Cies"
      print $author + " alustas KTurtle'i projekti aastal " + $year + "  ja ta töötab endiselt rõõmuga selle kallal!"

fontsize

      fontsize X

  `fontsize` määrab fondi suuruse, mida `print` kirjutamisel kasutab. `fontsize` sisend peab olema number. Suurus määratakse pikslites.

### Matemaatilised käsud

Järgmised käsud on &kturtle;'i keerukamad matemaatilised käsud.

round

      round(x)

  `round` ümardab antud arvu lähima täisarvuni.

      print round(10.8)
      forward 20
      print round(10.3)

  Selle koodiga kirjutab kilpkonn arvud 11 ja 10.

random (rnd)

      random X,Y

  `random` on käsk, mis tahab saada sisendit ja annab kohe ka väljundi. Sisendiks on kaks arvu, milles üks (X) määrab minimaalse ja teine (Y) maksimaalse väljundi. Väljund on juhuslik arv, mis on miinimumiga võrdne või suurem ning maksimumiga võrdne või väiksem. Üks väike näide:

      repeat 500 {
        $x = random 1,20
        forward $x
        turnleft 10 - $x
      }

  Käsuga `random` saab oma programmi veidi kaootilisemaks muuta.

sqrt

      sqrt X

  Käsk `sqrt` peab leidma arvu X ruutjuure.

pi

      pi

  See käsk tagastab konstandi pii `3,14159`.

sin
, cos
, tan

      sin X
      cos X
      tan X

  Need kolm käsku esindavad maailmakuulsaid trigonomeetrilisi funktsioone `sin`, `cos` ja `tan`. Nende käskude sisendargument X on arv.

arcsin
, arccos
, arctan

      arcsin X
      arccos X
      arctan X

  Need käsud on funktsioonide sin, cos and tan pöördväärtused. Nende käskude sisendargument X on arv.

### Sisendi- ja tagasisidedialoogid

Dialoog on väike hüpikaken, mis annab teatud tagasisidet või soovib saada mingit sisendit. &kturtle; kasutab dialoogidele kaht käsku: `message` ja `ask`.

message

      message X

  Käsk `message` vajab sisendina stringi. See näitab hüpikdialoogi, mis sisaldab stringi teksti.

      message  "Cies alustas KTurtle'iga aastal 2003  ja ta töötab endiselt rõõmuga selle kallal!"

ask

      ask X

  Käsk `ask` vajab sisendina stringi. See näitab hüpikdialoogi, mis sisaldab stringi nagu ka message. Kuid lisaks sellele on dialoogis ka sisendiväli. Selle abil saab kasutaja sisestada arvu või stringi, mis on võimalik salvestada muutujasse või edastada argumendina käsule. Näide:

      $in = ask "Kui vana sa oled?"
      $out = 2003 - $in
      print "Aastal 2003 olid sa " + $out + " aastat vana."

  Kui kasutaja sulgeb sisenddialoogi või ei sisesta midagi, on muutuja tühi.

## Muutujate omistamine

Kõigepealt vaatleme muutujaid, seejärel neile väärtuse omistamist.

Muutujad on sõnad, mille alguses seisab $. Redaktoris on nad esile tõstetud purpurse värviga.

Muutujad võivad sisaldada suvalist arvu, stringi või tõeväärtust. Omistamise `=` abil antakse muutujale sisu. See sisu püsib seni, kuni programm lõpetab käskude täitmise või kuni muutujale pole omistatud midagi muud.

Omistatud muutujaid saab seejärel kasutada vastavalt nende sisule. Võtame näiteks järgmise &turtlescript;i killukese:

    $x = 10
    $x = $x / 3
    print $x

Kõigepealt omistatakse muutujale `$x` väärtus `10`. Seejärel omistatakse muutujale `$x` iseenda väärtus jagatud `3`-ga — see tähendab, et muutuja `$x` väärtuseks saab tehte `10 / 3` tulemus. Lõpuks `$x` näidatakse. Teisel ja kolmandal real on näha, et muutujat `$x` kasutatakse nagu arvu.

Et muutujaid kasutada, tuleb neile väärtus omistada. Näide:

    print $n

See ei näita mitte midagi ja annab vaid veateate.

See oli lihtne, aga võtame kohe &turtlescript;i raskema näite:

    $a = 2004
    $b = 25

    # the next command prints "2029"
    print $a + $b
    backward 30
    # the next command prints "2004 plus 25 equals 2029"
    print $a + " plus " + $b + " equals " + ($a + $b)

Esimesel kahel real määratakse muutujate `$a` ja `$b` väärtuseks 2004 ja 25. Ülejäänud osa näitest koosneb kahest käsust `print`, mida eraldab käsk `backward 30`. Kommentaarid selgitavad, mida käsud teevad. Käsk `backward 30` on selleks, et iga väljund oleks ikka uuel real. Toodud näites on ka näha, et muutujaid saab kasutada nende sisuga mis tahes tehete sooritamiseks või sisendina, kui kutsuda välja mõni käsk.

Veel üks näide:

    $name = ask "What is your name?"
    print "Hi " + $name + "! Good luck while learning the art of programming..."

Siin on kõik päris selge ning ka siin võib näha, et muutujat `$name` kasutatakse nagu stringi.

Muutujate kasutamisel on suureks abiks inspektor. See näitab kõigi kasutusel olevate muutujate sisu.

## Täitmise kontrollimine

Täitmise kontrollerid lubavad — nagu nimetuski ütleb — kontrollida käsu täitmist.

Täitmise kontrollimise käsud on esile tõstetud tumerohelise rasvase kirjaga. Looksulud, mida väga sageli koos täitmise kontrolleritega pruugitakse, on esile tõstetud musta värviga.

### Kilpkonna ootelejätmine

Kui oled juba natuke &kturtle;'iga harjutanud, paned tähele, et kilpkonn võib päris kiiresti joonistada. See käsk muudab tema tegevuse aga veidi aeglasemaks.

wait

      wait X

  `wait` paneb kilpkonna X sekundiks ootama.

      repeat 36 {
        forward 5
        turnright 10
        wait 0.5
      }

  Selle koodiga joonistatakse ringjoon, aga kilpkonn ootab igal sammul pool sekundit. See jätab mulje nii enam-vähem normaalse kiirusega liikuvast kilpkonnast - vähemalt kilpkonna kohta...

### Tingimuse "kui" (if) täitmine

if

      if tõeväärtus { ... }

  Kood, mis seisab sulgudes, täidetakse ainult siis, kui (`if`) tõeväärtuse väärtus on tõene.

      $x = 6
      if $x > 5 {
        print "$x is greater than five!"
      }

  Esimesel real määratakse `$x` väärtuseks 6. Teisel real kasutatakse võrdlustehet `$x > 5` hindamiseks. Et hinnang on tõene ehk 6 on suurem kui 5, lubab täitmise kontroller `if` looksulgudes oleva koodi täita.

### Vastasel juhul ehk "else"

else

      if tõeväärtus { ... } else { ... }

  Kontrollerit `else` saab kasutada koos kontrolleriga `if`. Kood, mis seisab looksulgudes `else` järel, täidetakse ainult siis, kui tõeväärtuse väärtus on väär.

      reset
      $x = 4
      if $x > 5 {
        print "$x is greater than five!"
      } else {
        print "$x is smaller than six!"
      }

  Võrdlustehe hindab avaldist `$x > 5`. Et 4 ei ole suurem kui 5, on väärtuseks väär. See tähendab, et täidetakse kood, mis seisab looksulgudes `else` järel.

### Silmus "while"

while

      while tõeväärtus { ... }

  Täitmise kontroller `while` on üsna sarnane kontrolleriga `if`. Nende peamine erinevus seisab selles, et `while` kordab looksulgudes olevat koodi seni, kuni vastus tõeväärtus on lõpuks väär.

      $x = 1
      while $x < 5 {
        forward 10
        wait 1
        $x = $x + 1
      }

  Esimesel real määratakse `$x` väärtuseks 1. Teisel real hinnatakse avaldist `$x < 5`. Et vastus sellele küsimusele on tõene, alustab täitmise kontroller `while` looksulgudes oleva koodi täitmist ja teeb seda seni, kuni `$x < 5` on lõpuks väär. Antud juhul täidetakse looksulgudes olevat koodi neli korda, sest iga viienda rea täitmisega suureneb `$x` ühe võrra.

### Silmus "repeat"

repeat

      repeat arv { ... }

  Täitmise kontroller `repeat` on üpris sarnane kontrolleriga `while`. Erinevus seisab selles, et `repeat` kordab sulgudes olevat koodi määratud arv kordi.

### Arvestussilmus "for"

for

      for muutuja = arv to arv { ... }

  `for` on arvestussilmus, mis teeb midagi teatud arv kordi. Esimene arv määrab muutujale esimese silmuse väärtuse. Iga silmusega arv suureneb, kuni jõuab teise arvuni.

      for $x = 1 to 10 {
        print $x * 7
        forward 15
      }

  Igal looksulgudes oleva koodi täitmisel antakse `$x` väärtus ühe võrra suuremana, kuni `$x` võrdub lõpuks 10. Looksulgudes olev kood antud juhul kirjutab tehte '`$x` korda 7' tulemuse. Kui programm on töö lõpetanud, on tulemuseks lõuendil ilutsev numbri 7 korrutustabelike.

  Silmuse sammu vaikesuurus on 1, aga kasutada võib mis tahes väärtust.

      for muutuja = arv to arv step arv { ... }

### Silmusest väljumine

break

      break

  Katkestab otsekohe aktiivse silmuse ning annab järje üle vahetult silmuse järel seisvale lausele.

### Programmi täitmise peatamine

exit

      exit

  Lõpetab programmi täitmise.

## Omaenda käskude loomine käsuga learn

Käsk `learn` on väga eriline, sest selle abil saab luua omaenda käske. Sinu loodud käsk võib kasutada nii sisendit kui anda väljundit. Vaatamegi nüüd, kuidas uus käsk luua.

    learn ringjoon $x {
      repeat 36 {
        forward $x
        turnleft 10
      }
    }

Uus käsk kannab nime `ringjoon`. `ringjoon` kasutab sisendina argumenti, mis määrab ringjoone suuruse. `ringjoon` ei tagasta mingit väljundit. Nüüd võime käsku `ringjoon` kasutada täiesti tavalise käsuna, nagu selles näites:

    learn ringjoon $X {
      repeat 36 {
        forward $X
        turnleft 10
      }
    }

    go 200,200
    ringjoon 20

    go 300,200
    ringjoon 40

Järgmises näites aga loome väljundväärtusega käsu.

    learn faculty $x {
      $r = 1
      for $i = 1 to $x {
        $r = $r * $i
      }
      return $r
    }

    print faculty 5

Selles näites on uue käsu nimeks `faculty`. Kui käsu sisend on on `5`, siis väljund on `5*4*3*2*1`. Käsk `return` määrab kindlaks väärtuse ning täitmisega tagastataksegi väljundväärtus.

Käskudel võib olla enam kui üks sisend. Järgmises näites luuakse käsk, mis toob kaasa ristküliku joonistamise.

    learn box $x, $y {
      forward $y
      turnright 90
      forward $x
      turnright 90
      forward $y
      turnright 90
      forward $x
      turnright 90
    }

Nüüd võid käivitada `box 50, 100` ning kilpkonn joonistab lõuendile ristküliku.