# &turtlelang; Programming Reference

This is the reference for &kturtle;'s &turtlelang;. In this chapter we first briefly touch all the different instruction types. Then the commands are explained one by one. Then containers, math, questions and execution controllers are explained. At last you are shown how to create you own commands with learn.

## Different Instruction Types

As in any language, &turtlelang; has different types of words and symbols. Here the differences between the types are briefly explained.

### Kommandon

Using commands you tell the turtle or &kturtle; to do something. Some commands need input, some give output.

    # forward is a command that needs input, in this case the number 100:
    forward 100

For a detailed overview of all commands that &kturtle; supports go here.

### Tal

Troligen kan du redan en hel del om tal. Sättet som tal används i &kturtle; är inte särskilt annorlunda än ett talat språk eller matematik.

Vi har de så kallade naturliga talen: `0`, `1`, `2`, `3`, `4`, `5`, etc. De negativa talen: `-1`, `-2`, `-3`, etc. Och talen med decimaler eller decimaltalen, till exempel: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

Numbers can be used in mathematical calculations and questions. They can also be put in containers.

Numbers are highlighted with dark red in the code editor.

### Strängar

Först ett exempel:

    skriv "Hej, jag är en sträng."

I det här exemplet är `skriv` ett kommando, medan `"Hej, jag är en sträng."` är en sträng. Strängar börjar och slutar med tecknet `"`. Det är dessa tecken som gör att &kturtle; vet att det är en sträng.

Strings can be put in containers. Yet they cannot be used in mathematical calculations and questions.

Strings are highlighted with red in the code editor.

### Names

When using the &turtlelang; programming language you create new things. If you write a program you will often need containers and in some cases you need learn to create new commands. When making a new command with learn you will have to specify a name.

You can choose any name, as long as it does not already have a meaning. For instance you cannot name a function forward, since that name is already used for an internal command.

    # here forward is used as a new command,
    # but it already has a meaning so
    # this will produce an error:
    learn forward {
      print "this is invalid"
    }

    # this works:
    learn myforward {
      print "this is ok"
    }

Names can contain only letters, numbers and underscores (_). Yet they have to start with a letter. Container names have to start with the container prefix ($).

    # here forward is used as a container,
    # starting with the $ prefix, so it does
    # not conflict with the forward command
    $forward = 20
    print $forward

Containers are highlighted with bolded purple in the code editor.

Please read the documentation on containers and the learn command for a better explanation and more examples.

### Assignments

Assignment are done with the `=` symbol. In programming languages it is better to read the single `=` not as 'equals' but as 'becomes'. The word 'equals' is more appropriate for the `==` which is a question.

Assignments are generally use for two reasons, (1) to add content containers, and (2) to modify the content of a container. For example:

    $x = 10
    # the container x now contains the number 10
    $W = "My age is: "
    # the container W now contains the string "My age is: "
    # this prints the content of the containers 'W' and 'x' on the canvas
    print $W + $x

For more examples see the section that explains containers.

### Math Symbols

&kturtle; supports all basic math symbols: add (`+`), subtract (`-`), multiply (`*`), divide (`/`) and the brackets `(` and `)`.

For a complete explanation and more examples see the math section.

### Questions

We can ask simple questions on which the answer will be 'true' or 'false'.

Using questions is extensively explained in the questions section.

### Question Glue-Words

Questions can be glued together with so called 'question glue'. The glue words are `and`, `or`, and a special glue-word: `not`.

Using question-glue is explained in the Question Glue section.

### Kommentarer

Comments are lines that start with a `#`. For example:

    # this is a comment!
    print "this is not a comment"
    # the previous line is not a comment, but the next line is:
    # print "this is not a comment"

We can add comments to the code for ourselves or for someone else to read. Comments are used for: (1) adding a small description to the program, (2) explaining how a piece of code works if it is a bit cryptic, and (3) to 'comment-out' lines of code that should be (temporarily) ignored (see the last line of the example).

Commented lines are highlighted with light grey in the code editor.

## Kommandon

Using commands you tell the turtle or &kturtle; to do something. Some commands need input, some give output. In this section we explain all the commands that can be used in &kturtle;. Please note that all build in commands we discuss here are highlighted with blue in the code editor, this can help you to distinguish them.

### Flytta sköldpaddan

Det finns flera kommandon för att flytta sköldpaddan över skärmen.

framåt (fr)

      framåt X

  `framåt` flyttar sköldpaddan framåt X bildpunkter. När pennan är sänkt lämnar sköldpaddan ett spår. `framåt` kan förkortas `fr`.

bakåt (ba)

      bakåt X

  `bakåt` flyttar sköldpaddan bakåt X bildpunkter. När pennan är sänkt lämnar sköldpaddan ett spår. `bakåt` kan förkortas `ba`.

svängvänster (sv)

      svängvänster X

  `svängvänster` talar om för sköldpaddan att svänga X grader åt vänster. `svängvänster` kan förkortas till `sv`.

svänghöger (sh)

      svänghöger X

  `svänghöger` talar om för sköldpaddan att svänga X grader åt höger. `svänghöger` kan förkortas till `sh`.

riktning (ri)

      riktning X

  `riktning` ställer in sköldpaddans riktning till X grader från noll, och är på så sätt inte relativ till sköldpaddans tidigare riktning. `riktning` kan förkortas till `ri`.

mitten

      mitten

  `mitten` flyttar sköldpaddan till dukens mitt.

gå

      gå X,Y

  `gå` talar om för sköldpaddan att gå till en viss plats på duken. Den platsen är X bildpunkter från dukens vänsterkant och Y bildpunkter från dukens överkant.

gåx

      gåx X

  `gåx` gör att sköldpaddan flyttas X bildpunkter från dukens vänsterkant, medan den bibehåller samma höjd.

gåy

      gåy Y

  `gåy` gör att sköldpaddan flyttas Y bildpunkter från dukens överkant, medan den behåller samma avstånd från dukens vänsterkant.

När kommandona `gå`, `gåx`, `gåy` och `mitten` används ritar sköldpaddan inte någon linje oberoende av om pennan är uppe eller nere.

### Var är sköldpaddan?

Det finns två kommandon som returnerar sköldpaddans position på skärmen.

hämtax

  `hämtax` returnerar antal bildpunkter från dukens vänsterkant till sköldpaddans nuvarande position.

hämtay

  `hämtay` returnerar antal bildpunkter från dukens överkant till sköldpaddans nuvarande position.

### Sköldpaddan har en penna

Sköldpaddan har en penna som ritar en linje medan sköldpaddan rör sig. Det finns några få kommandon att styra pennan. I det här avsnittet förklarar vi dessa kommandon.

höjpenna (hp)

      höjpenna

  `höjpenna` lyfter pennan från duken. När pennan är höjd, ritas ingen linje när sköldpaddan rör sig. Se också `sänkpenna`. `höjpenna` kan förkortas till `hp`.

sänkpenna (sp)

      sänkpenna

  `sänkpenna` sänker ner pennan på duken. När pennan är sänkt, ritas en linje när sköldpaddan rör sig. Se också `höjpenna`. `sänkpenna` kan förkortas till `sp`.

pennbredd (pb)

      pennbredd X

  `pennbredd` ställer in pennans bredd (linjebredden) till X bildpunkter. `pennbredd` kan förkortas till `pb`.

pennfärg (pf)

      pennfärg R,G,B

  `pennfärg` ställer in pennans färg. `pennfärg` behöver en RGB-kombination som indata. `pennfärg` kan förkortas till `pf`.

### Kommandon för att kontrollera duken

Det finns flera kommandon för att kontrollera duken.

dukstorlek (ds)

      dukstorlek X,Y

  Med kommandot `dukstorlek` kan du ställa in dukens storlek. Den har X och Y som indata, där X är den nya dukbredden i bildpunkter, och Y är den nya höjden av duken i bildpunkter. `dukstorlek` kan förkortas till `ds`.

dukfärg (df)

      dukfärg R,G,B

  `dukfärg` ställer in dukens färg. `dukfärg` behöver en RGB-kombination som indata. `dukfärg` kan förkortas till `df`.

### Kommandon för att städa

Det finns två kommandon för att städa duken efter du har ställt till den.

rensa (ren)

      rensa

  Med `rensa` suddar du allt som ritats på duken. Allt annat blir kvar: sköldpaddans position och vinkel, dukfärgen, sköldpaddans synlighet och dukstorleken.

återställ

      återställ

  `återställ` städar mycket noggrannare än kommandot `rensa`. Efter kommandot `återställ` är allt som det var precis när du startat &kturtle;. Sköldpaddan är placerad i mitten av skärmen, dukfärgen är vit, sköldpaddan ritar en svart linje på duken och dukstorleken är inställd till 400 x 400 bildpunkter.

### Sköldpaddan är en sprite

Först en kort förklaring av vad en sprite är: En sprite är en liten bild som kan flyttas omkring på skärmen, som vi ofta ser i datorspel. Vår sköldpadda är alltså en sprite. För ytterligare information se ordförklaringen av sprite.

Härnäst hittar du en fullständig översikt av alla kommandon som arbetar med en sprite.

(Kturtles nuvarande version stöder ännu inte användning av någon annan sprite än sköldpaddan. I framtida versioner kommer du att kunna ändra sköldpaddan till något som du själv skapat.)

visa (vi)

      visa

  `visa` gör sköldpaddan synlig igen efter den har gömts. `visa` kan förkortas till `vi`.

göm

      göm

  `göm` gömmer sköldpaddan. Det kan användas om sköldpaddan inte passar in i bilden. `göm` kan förkortas `gö`.

### Kan sköldpaddan skriva?

Svaret är ja. Sköldpaddan kan skriva. Den skriver nästan vad som helst som du talar om för den att skriva.

skriv

      skriv X

  Kommandot `skriv` används för att tala om för sköldpaddan att skriva någonting på duken. `skriv` behöver tal och strängar som indata. Du kan använda `skriv` för att skriva ut olika tal och strängar med symbolen '+'. Här är ett litet exempel:

      $år = 2003
      $upphovsman = "Cies"
      skriv $upphovsman + " startade projektet Kturtle " + $år + " och gillar ännu att jobba med det!"

teckenstorlek

      teckenstorlek X

  `teckenstorlek` anger storlek på teckensnittet som används av `skriv`. `teckenstorlek` behöver indata som ska vara ett tal. Storleken ställs in i bildpunkter.

### A command that rolls dice for you

There is one command that rolls dice for you, it is called `random`, and it is very useful for some unexpected results.

slump (slu)

      slump X,Y

  `slump` är ett kommando som kräver indata och ger utdata. Två tal krävs som indata, det första (X) anger minimal utdata och det andra (Y) anger maximal. Utdata är ett slumpmässigt valt tal som är större än eller lika med minimum och mindre än eller lika med maximum. Här är ett litet exempel:

      upprepa 500 {
        $x = slump 1,20
        framåt $x
        svängvänster 10 - $x
      }

  Med kommandot `slump` kan du lägga till en viss mängd kaos i programmet.

### Inmatning och återmatning via dialogrutor

En dialogruta är ett litet fönster som dyker upp och tillhandahåller återmatning eller frågar efter inmatning. &kturtle; har två kommandon för dialogrutor, närmare bestämt `meddelande` och `fråga`.

meddelande

      meddelande X

  Kommandot `meddelande` har en sträng som indata. Det visar en dialogruta som innehåller texten från strängen.

      message "Cies started the KTurtle project in 2003 and still enjoys working on it!"

fråga

      fråga X

  `ask` takes a string as input. It shows a pop-up dialog containing the text from the string, just like the message. But in addition to it also puts an input field on the dialog. Through this input filed the user can enter a number or a string which can be stored in a container. For example

      $in = ask "What is you age?"
      $out = 2003 - $in
      print "In 2003 you where " + $out + " years old at some point."

  When a user cancels the input dialog, or does not enter anything at all the container is emptied.

## Containers

Containers are letters or words that can be used by the programmer to store a number or a text. Containers that contain a number are called variables, containers that can contain text are called string. Containers can be identified by the container character $ that precedes their usage.

Containers that are not used contain nothing. An example:

    print $N

This will print nothing and you get an error message.

### Variables: number containers

Let us start with an example:

    $x = 3
    print $x

In the first line the letter `x` is made into a variable (number container). As you see the value of the variable `x` is set to 3. On the second line the value is printed.

Note that if we wanted to print an x that we should have written

    print "x"

That was easy, now a bit harder example:

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

    # the next command prints "2029"
    print $C
    backward 30
    # the next command prints "2004 plus 25"
    print $A + " plus " + $B
    backward 30
    # the next command prints "1979"
    print $A - $B

In the first two lines the variables `A` and `B` are set to 2004 and 25. On the third line the variable `C` is set to `A + B`, which is 2029. The rest of the example consists of 3 `print` commands with `backward 30` in between. The `backward 30` is there to make sure every output is on a new line. In this example you also see that variables can be used in mathematical calculations.

### Containers that contain text (strings)

In programming code the regular text is usually started and ended with quotes. As we have already seen:

    print "Hello programmer!"

The regular is delimited with quotes. These pieces of regular text we call strings.

Strings can also be stored in containers just like numbers Strings are a lot like variables. The biggest difference is that they contain text in stead of numbers. For this reason strings cannot be used in mathematical calculations and questions. An example of the use of strings:

    $x = "Hello "
    $name = ask "Please enter your name..."
    print $x + $name + ", how are you?"

On the first line the string `x` is set to Hello . On the second line the string `name` is set to the output of the `ask` command. On the third line the program prints a composition of three strings on the canvas.

This program ask you to enter your name. When you, for instance, enter the name Paul, the program prints Hello Paul, how are you?. Please note that the plus (+) is the only math symbol that you can use with strings.

## Can the Turtle do math?

Yes, &kturtle; will do your math. You can add (+), subtract (-), multiply (*), and divide (/). Here is an example in which we use all of them:

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

Do you know what value a, b, c and d have? Please note the use of the assignment symbol `=`.

Om du bara vill göra en enkel beräkning kan du skriva något som liknar detta:

    print 2004-12

Now an example with parentheses:

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

The expressions inside parentheses will be calculated first. In this example, 20-5 will be calculated, then multiplied by 2, divided by 30, and then 1 is added (giving 2).

&kturtle; has advanced mathematical features. It knows the number `pi` and trigonometrical functions like `sin`, `cos`, `tan`, `arcsin`, `arccos`, `arctan` and the functions `sqrt` and `exp`.

### Let the turtle round your numbers

If you need integers in calculations, use this function.

avrunda

      avrunda(x)

  `round` the given number to the nearest integer.

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

  With this code the turtle will print the numbers 11 and 10.

## Asking questions, getting answers...

`if` and `while` are execution controllers that we will discuss in the next section. In this section we use the `if` command to explain questions.

### Questions

A simple example of a question:

    $x = 6
    if $x > 5 {
      print "hello"
    }

In this example the question is the `x > 5` part. If the answer to this question is 'true' the code between the brackets will be executed. Questions are an important part of programming and often used together with execution controllers, like `if`. All numbers and variables (number containers) can be compared to each other with questions.

Here are all possible questions:

#### Types of questions

`a == b` | equals | answer is true if `a` equals `b`
`a != b` | not-equals | answer is true if `a` does not equal `b`
`a > b` | greater than | answer is true if `a` is greater than `b`
`a < b` | smaller than | answer is true if `a` is smaller than `b`
`a >= b` | greater than or equals | answer is true if `a` is greater than or equals `b`
`a <= b` | smaller than or equals | answer is true if `a` is smaller than or equals `b`

### Question Glue

Question glue-words enable us to glue questions into one big question.

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

In this example the glue-word `and` is used to glue 2 questions (`a < 5`, `b == 5`) together. If one side of the `and` would answer false the whole question would answer false, because with the glue-word `and` both sides need to be true in order to answer true. Please do not forget to use the brackets around the questions!

Here is a schematic overview; a more detailed explanation follows below:

#### Question glue-words

`and` | Both sides need to be 'true' in order to answer 'true'
`or` | If one of the sides is 'true' the answer is 'true'
`not` | Special case: only works on one question! Changes 'true' into 'false' and 'false' into 'true'.

#### and

When two questions are glued together with `and`, both sides of the `and` have to be 'true' in order to result in 'true'. An example:

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

In this example you see a glued question glued onto an other question.

#### or

If one of the two questions that are glued together with `or` is 'true' the result will be 'true'. An example:

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

In this example you see a glued question glued onto an other question.

#### not

`not` is a special question glue-word because it only works for one question at the time. `not` changes 'true' into 'false' and 'false' into 'true'. An example:

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

In this example the glued question is 'true' yet the `not` changes it to 'false'. So in the end `"not hello ;-)"` is printed on the canvas.

## Styra körning

Styrning av körningen gör det möjligt för dig att styra körningen, precis som namnet anger.

Execution controlling commands are highlighted with dark green in a bold font type. The brackets are mostly used together with execution controllers and they are highlighted with bolded black.

### Låta sköldpaddan vänta

Om du försökt programmera en del med &kturtle; kanske du märker att sköldpaddan kan vara mycket snabb när den ritar. Det här kommandot gör att sköldpaddan väntar en angiven tid.

vänta

      vänta X

  `vänta` låter sköldpaddan vänta X sekunder.

      upprepa 36 {
        framåt 5
        svänghöger 10
        vänta 0.5
      }

  Den här koden ritar en cirkel, men sköldpaddan väntar en halv sekund mellan varje steg. Det ger intrycket av en sköldpadda som rör sig långsamt.

### Kör "om"

om

      if question { ... }

  The code that is placed between the brackets will only be executed `if` the answer to the question is true. Please read for more information on questions in the question section.

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

  On the first line `x` is set to 6. On the second line the question `x > 5` is asked. Since the answer to this question is true the execution controller `if` will allow the code between the brackets to be executed

### Om inte, med andra ord "annars"

annars

      if question { ... } else { ... }

  `else` can be used in addition to the execution controller `if`. The code between the brackets after `else` is only executed if the answer to the question that is asked is false.

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

  The question asks if `x` is greater than 5. Since `x` is set to 4 on the first line the answer to the question is false. This means the code between the brackets after `else` gets executed.

### En "medan" snurra

medan

      while question { ... }

  The execution controller `while` is a lot like `if`. The difference is that `while` keeps repeating (looping) the code between the brackets until the answer to the question is false.

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

  On the first line `x` is set to 1. On the second line the question `x < 5` is asked. Since the answer to this question is true the execution controller `while` starts executing the code between the brackets until the answer to the question is false. In this case the code between the brackets will be executed 4 times, because every time the fifth line is executed `x` increases by 1.

### En "upprepa" snurra

upprepa

      repeat number { ... }

  The execution controller `repeat` is a lot like `while`. The difference is that `repeat` keeps repeating (looping) the code between the brackets for the given number.

### En "för" snurra, en räknande snurra

för

      for start point to end point { ... }

  The `for` loop is a counting loop, &ie; it keeps count for you.

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

  Every time the code between the brackets is executed the `x` is increased by 1, until `x` reaches the value of 10. The code between the brackets prints the `x` multiplied by 7. After this program finishes its execution you will see the times table of 7 on the canvas.

  Den förvalda stegstorleken i en snurra är 1, du kan använda ett annat värde med:

      for start point to end point step step size { ... }

### Lämna en snurra

avbryt

      avbryt

  Terminates the current loop immediately and transfers control to the statement immediately following that loop

### Stop the turtle

avsluta

      avsluta

  Finishes the execution of the code.

## Skapa dina egna kommandon med lär

`learn`
is a very special command, because it is used to create your own commands. The command you create can take input and return output. Let us take a look at how a new command is created:

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

The new command is called `circle`. `circle` takes one input, a number, to set the size of the circle. `circle` returns no output. The `circle` command can now be used like a normal command in the rest of the code. See this example:

    lär cirkel $x {
      upprepa 36 {
        framåt $x
        svängvänster 10
      }
    }

    gå 200,200
    cirkel 20

    gå 300,200
    cirkel 40

In the next example, a command with a return value is created.

    reset

    learn multiplyBySelf $n {
      $r = $n * $n
      return $r
    }
    $i = ask "Please enter a number and press OK"
    print $i + " multiplied by itself is: " + multiplyBySelf $i

In this example a new command called `multiplyBySelf` is created. The input of this command is multiplied by itself and then returned, using the `return` command. The `return` command is the way to output a value from a function you have created.

Commands can have more than one input. In the next example, a command that draws a rectangle is created.

    learn box $X, $Y {
      forward $Y
      turnright 90
      forward $X
      turnright 90
      forward $Y
      turnright 90
      forward $X
      turnright 90
    }

Now you can run `box 50, 100` and the turtle will draw a rectangle on the canvas.