The Tampio Programming Language

Tampio is an object-oriented programming language that looks like a natural language – Finnish. It is named after a famous Finnish programmer.

To see this language in action, see the Tic-Tac-Toe example. (For technical reasons, it's named "ristiruutu" instead of "ristinolla", which is the proper Finnish translation.)

This branch currently contains a new iteration of the language that is imperative instead of functional. The functional language is in the functional branch.

Dependencies

• Python 3
• Libvoikko (package libvoikko in Ubuntu and Fedora). It seems that some versions of Voikko are not compatible. I have tested that the program works with 3.8 and 4.1.1.
• Finnish morphological dictionary (Eg. this or this. The latter may work better with newer versions of libvoikko, but the former is confirmed to work with libvoikko 3.8.)

The morphological dictionary must be unzipped to ~/.voikko/.

Usage

To open an interactive prompt:

python3 tampio.py

To compile a file to JavaScript:

python3 tampio.py file.itp

To print Markdown code that contains the syntax highlighting data of the file:

python3 tampio.py -s markdown-lists file.itp

To print a HTML page that contains both JavaScript and the syntax highlighted code:

python3 tampio.py -i -p file.itp

Introduction

Tampio is an object-oriented language that compiles to JavaScript. Its syntax is directly inspired by the Finnish language and is therefore based on inflecting words.

A Tampio file is a list of definitions, each which defines either a class, a function, a method, a comparison operator or a global variable. For example, here is a simple program that calculates the factorial of a given number.

Pienen luvun kertoma on
    riippuen siitä, onko se pienempi tai yhtä suuri kuin yksi,
    joko yksi
    tai pieni luku kerrottuna pienen luvun edeltäjän kertomalla.

Luvun edeltäjä on se vähennettynä yhdellä.

Olkoon pieni muuttuja uusi muuttuja, jonka arvo on nolla.

Kun nykyinen sivu avautuu,
    pieneen muuttujaan luetaan luku
    ja nykyinen sivu näyttää pienen muuttujan arvon kertoman.

It contains two functions definitions, one variable definition and one method definition. Let's iterate these line by line.

Pienen luvun kertoma on

This is the signature of the kertoma function, which has one parameter pieni luku. As you can see, the name of the parameter comes before the name of the function and is in the genitive case. The last word, on, is a keyword that separates the signature of the function and its body.

riippuen siitä, onko se pienempi tai yhtä suuri kuin yksi,

This is a ternary expression. It tests if se is less than or equal to (pienempi tai yhtä suuri kuin) one (yksi). se is like this in JavaScript and always means the first parameter (here pieni luku).

joko yksi

If the condition is true, the function returns one, (yksi). joko is a keyword that comes after the condition of riippuen siitä expression.

tai pieni luku kerrottuna pienen luvun edeltäjän kertomalla.

If the condition is false (pieni luku is greater than one), the function returns the value of this expression. It is a product (kerrottuna is the multiplication operation) of pieni luku and pienen luvun edeltäjän kertoma. The right operand of kerrottuna consists of two function calls (which are similar to the signature of the function). First, the predecessor (edeltäjä) of pieni luku is calculated, and then its factorial (kertoma). The arguments of functions are in the genitive case.

Luvun edeltäjä on se vähennettynä yhdellä.

This is a helper function that calculates the predecessor of a number. It simply consists of a vähennettynä operator with operands se (the parameter) and yksi (one).

Olkoon pieni muuttuja uusi muuttuja, jonka arvo on nolla.

Olkoon is a keyword that is used to define global variables. The name of the variable is pieni muuttuja and its value is a new object. The object is created using the uusi keyword and its type is the muuttuja class. jonka keyword is used to set the initial values of the fields of the object. In this case, the arvo field is initialized to nolla (zero).

Kun nykyinen sivu avautuu,

This line declares a new method for the sivu class. (sivu is an alias to the HTMLDocument JavaScript class.) It begins with the Kun keyword. The name of the method is avautuu and the name of the "self" object is nykyinen sivu. (As in Python, the "self" object must be named in the signature of a method.)

pieneen muuttujaan luetaan luku

Here we call the luetaan luku method of pieni muuttuja. The method will prompt a number from the used and store it to the arvo field of pieni muuttuja. pieni muuttuja is in the illative case, because the luetaan luku method requires that case.

ja nykyinen sivu näyttää pienen muuttujan arvon kertoman.

ja keyword is used to specify that this is the last statement in the body of the method. It is another method call, calling the näyttää method of nykyinen sivu. (An alias to HTMLDocument.write.) The argument of the method is a function call and the argument of kertoma is pienen muuttujan arvo (note the genitive case of both arguments). The field access syntax is identical to the function call syntax.

Lists

List syntax is used always when there is a block containing multiple items. The block can be a body of a class, function, if statement or an array.

In many programming languages blocks are created with keywords or symbols that mark the beginning and the end of the block, for example begin/end or {/}. In Tampio, as in natural languages, the block (called a list) is instead defined by using special separators that mark either continuation or ending of the list.

After each item in the list except the last, there must be a separator token. A comma (,) is used when the list continues after the following item, and ja is used when the list ends after the following item.

[first item], [second item], ..., [second-last item] ja [last item]

There is a special syntax that must be used when there is only one item in the list:

[only item] eikä muuta

However, if the current definition would end immediately after the list (ie. there is a period), it is allowed to leave eikä muuta out.

Classes

As Tampio is an object-oriented language, classes are a crucial feature. Each class is defined using a set of fields and number of methods. The fields must be defined together with the class, but methods can be added afterwards.

A class declaration consists of the name of the class in the adessive case and the on keyword.

[name/adessive] on [field list/nominative].

For example:

Vektorilla on komponentit.

This very simple class, vektori, has one field: komponentit. As the name of the field is plural, it is an array.

There is a special syntax that is used to declare a subclass:

[name/nominative] on [super type/nominative], jolla on [field list/nominative].

Fields

Each field is simply either a singular or plural noun. Plural nouns are arrays, singular nouns objects.

A field can have a default value that can be set using one of the following alternative syntaxes:

[field name/nominative], joka on [predicative/nominative],
[field name/nominative], joka on aluksi [predicative/nominative],
[field name/nominative], joka on alussa [predicative/nominative],
[field name/nominative], joka on yleensä [predicative/nominative],
[field name/nominative] [[predicative/nominative]]
[field name/nominative] [aluksi [predicative/nominative]]
[field name/nominative] [alussa [predicative/nominative]]
[field name/nominative] [yleensä [predicative/nominative]]

Please note that some syntaxes contain the literal [] characters.

Functions

In Tampio, a function is always defined for one class and is polymorphic to that class. This means that it is possible to define the same function differently for multiple classes.

A function normally has one parameter and one expression that is the return value. Certain essive functions can have two parameters.

[parameter/genitive] [function name] on [predicative/nominative].
[parameter/nominative] [function name/essive] on [predicative/nominative]
[parameter/nominative] [function name/past passive participle essive] [parameter] on [predicative/nominative]

The name of the parameter must have two words: an adjective and the name of the class. For example, to define a function called dimensio for the vektori class, we must use parameter name that ends in vektori:

Lyhyen vektorin dimensio on lyhyen vektorin komponenttien määrä.

This function will return the dimension of a vector, that is, the number of its components. The name of the function is dimensio and its parameter is lyhyt vektori. määrä is a function that return the size of a list.

Here's another function that return the "tail" of a vector:

Lyhyen vektorin häntä on uusi vektori, jonka komponentit ovat lyhyen vektorin komponentit toisesta alkaen.

Again, its parameter is lyhyt vektori. The function returns a new vector (using the uusi keyword), and its components are formed using the slice syntax.

It is possible to not name the parameter, in which case only the class name appears in the signature. In the body, the word se can be used to refer to the unnamed parameter.

Vektorin dimensio on sen komponenttien määrä.

If the function name is in essive case and is a past passive participle (ie. ending with -ttuna/-ttynä), it can have an optional second parameter.

Methods

A method is a procedure that can take multiple arguments.

Kun [self parameter] [method name] [parameters], [statement list].

The method name consists of a verb and optionally some noun modifiers.

Each parameter must be in a different case or have a postposition.

The order of parameters does not have any significance (other than that the self parameter must come before the verb). The parameters are identified by their case or postposition.

The following method iterates the components of a vector and prints them:

Kun lyhyt vektori painetaan nykyiselle sivulle,
	jos lyhyen vektorin dimensio ei ole nolla,
		nykyinen sivu näyttää lyhyen vektorin ensimmäisen komponentin
		ja lyhyen vektorin häntä painetaan nykyiselle sivulle.

Postpositions

Postpositions are used to identify the parameters when they are not identified by cases. The parameter must usually be in the genitive case and the postposition must immediately follow it. These rules are the same in both method definitions and method calls.

[parameter/required case] [postposition]
[parameter/genitive] [intransitive verb past passive participle/partitive]

The passive past participles of intransitive verbs ending in -uttu/-ytty work similarly to postpositions.

For example:

toteuteutetaan työ annettujen ohjeiden mukaisesti
lisätään loistava luku lyhyen listan eteen
luetaan arvo oivan osoittimen alta mukavaan muuttujaan
noustaan ilmaan 3 sekunnin kuluttua

Kun toistetaan n kertaa tehokas toiminto,
    jos n on suurempi kuin nolla, niin
        tehokas toiminto suoritetaan
    ja  toistetaan m kertaa tehokas toiminto, missä m on n vähennettynä yhdellä.

Comparison operators and other boolean functions

Boolean functions are functions that return boolean values. They can only be used inside other boolean functions, if statements and ternary expressions.

[parameter/nominative] on [function name], jos [condition expression].
[parameter/nominative] on [adjective/comparative nominative] kuin [parameter/nominative], jos [condition expression].
[object] [verb] [arguments], jos [condition expression]

The function can have either "olla" verb or any other verb. If the verb is olla, there must be a word after the verb.

If the word is a comparative adjective, it must also be nominative and be followed by the kuin keyword. This kind of functions are called comparison operators.

Otherwise, it can be any word that doesn't start a nominal phrase expression.

If the verb is not olla, the boolean function looks like a method, consisting of one or more arguments that must all be in a different case or have a different postposition.

For example:

Lista on tyhjä, jos sen alkioiden määrä on nolla.
Vektori on pidempi kuin lyhyt vektori, jos sen pituus on suurempi kuin lyhyen vektorin pituus.
Lista sisältää ihanan alkion, jos sen jokin alkio on sama kuin ihana alkio.

Statements

The body of a method is a list of statements.

Method calls

A method call is written in same way as the signature of the method called.

[object] [verb] [arguments]

For example, to call the painetaan method of vektori (defined above) when the object is in variable villi vektori:

villi vektori painetaan nykyiselle sivulle

If the method returns a value, it can be stored using the tuloksena keyword. If the verb is expressed in active voice, the keyword must have the -an possessive suffix.

[object] [verb/active] [arguments] tuloksenaan [variable]
[object] [verb/passive] [arguments] tuloksena [variable]

A method call there may be a missä modifier, which is used to introduce temporary variables. They can be referenced in the call immediately before, and in all calls after the modifier. There must be a comma before missä.

, missä [assignment list],

Each assignment has a variable name and a value:

[variable name/nominative] on [expression/nominative]

For example, to call painetaan with a new vector, we could write

uusi vektori, jonka komponentteja ovat yksi, kaksi ja kolme eikä muuta,
	painetaan nykyiselle sivulle

However, it is may be clearer to use a missä clause to create a temporary variable,

väliaikainen vektori painetaan nykyiselle sivulle,
	missä väliaikainen vektori on uusi vektori, jonka komponentteja ovat yksi, kaksi ja kolme eikä muuta

missä clauses are also used to create single-letter variables, which can be used in array subscripts and mathematical expressions.

nykyinen sivu näyttää villin vektorin n:nnen komponentin,
    missä n on villin vektorin dimensio vähennettynä kahdella,

Asynchronous calls

If the method returns a JavaScript Promise (or any similar object), the then and catch methods can be called using a special syntax.

, minkä [method name] [lambda parameter name] [method call],

The lambda parameter name will be the self argument of the following method call.

vaikea laskutoimitus tehdään, minkä jälkeen saatu tulos kirjataan lokiin,
# vaikea_laskutoimitus.tehdä_P__N().then(saatu_tulos => console.log(saatu_tulos))

minkä -clauses can be chained using the list syntax, but eikä muuta cannot be used.

älykäs komponentti aloittaa toimenpiteen,                # älykäs_komponentti.aloittaa_toimenpide_P__N()
minkä onnistuessa saatu tulos kirjataan lokiin           #     .then(saatu_tulos => console.log(saatu_tulos))
ja minkä epäonnistuessa syntynyt virhe kirjataan lokiin, #     .catch(saatu_tulos => console.log(saatu_tulos))

Return statements

A method can return a value using the return statement.

[expression/nominative] palautetaan

For example, to return a zero:

nolla palautetaan

For each statements

There are no for loops (or any kind of loops) in Tampio. However, there is a statement roughly equivalent to the forEach method in JavaScript.

If any subexpression of a statement contains the word jokainen in place of an ordinal in an array subscript, the statement is evaluated once for each element in the array.

nykyinen sivu näyttää lyhyen vektorin jokaisen komponentin

If statements

If statements are used to execute other statements conditionally. An if statement consists of a condition and a list of substatements. There should be a comma before jos. The niin keyword can be used in place of eikä muuta, when there is only one condition.

, jos [condition expression], niin [statement list]
, jos taas [condition expression], niin [statement list]
, jos kuitenkin [condition expression], niin [statement list]

If either of taas or kuitenkin is present, the if statement will be evaluated only if the previous if statement was not evaluated (ie. it is an "else if" statement).

For example, to iterate an array, one must write a recursive method. An if statement is used to end the recursion when the array is empty. Below is a pseudocode of such iteration method.

Kun pitkää listaa iteroidaan,
	jos pitkän listan alkioiden määrä ei ole nolla,
	niin
		pitkän listan ensimmäinen alkio käsitellään
	ja	pitkän listan häntää iteroidaan.

An real example would be the painetaan method described in the Methods chapter.

Condition expressions

A condition expression is a list of conditions separated by logical connectives ja, sekä, tai and taikka. ja and tai have higher precedence than respective sekä and taikka.

A condition can be either a builtin operator or a boolean function. Boolean functions are described in a previous chapter.

Builtin operators

A condition can be a builtin operator. The condition consists of two operands and a comparison operator.

[expression] on [operator] [expression]
[expression] ei ole [operator] [expression]

The ei keyword is used to negate the condition. Below is a table of available comparison operators.

Quantifiers

It is possible to use jokainen, mikään and jokin quantifiers in conditions. They correspond to JavaScript methods .every and .some.

For example:

pitkän listan jokin alkio on tyhjä      # pitkä_lista.some(jokin_alkio => jokin_alkio.c_tyhjä())
pitkän listan jokainen alkio on tyhjä   # pitkä_lista.every(jokainen_alkio => jokainen_alkio.c_tyhjä())
pitkän listan mikään alkio ei ole tyhjä # pitkä_lista.every(mikään_alkio => !mikään_alkio.c_tyhjä())

Assignments

There are several ways to create variables in Tampio: joka on expressions, uusi expressions, missä clauses, return value assignments, assignment statements and parameter declarations. Return value assignments are covered in the method call chapter. Assignment statements consist of the name of the variable or field in the translative case and an expression.

[lval/translative] asetetaan [expression/nominative]

For example:

kivan kaverin kuvaukseksi asetetaan teksti "Hän on kiva"

A special type of assignment is the increment statement, which adds a value to a variable.

[lval/partitive] kasvatetaan [expression/adessive]

For example:

loistavaa laskuria kasvatetaan yhdellä
nykyisen pelaajan pisteitä kasvatetaan 100:lla

There is also a special syntax to add a new item to a list, implemented as a method of the array class. It is similar to the assignment syntax, but the verb is lisätään instead of asetetaan.

[list/translative singular] lisätään [expression/nominative]
[list/translative plural] lisätään [jokainen expression/nominative]

For example:

kivan kaverin ystäväksi lisätään mukava kaveri
kivan kaverin ystäviksi lisätään jokainen mukavan kaverin ystävä

Method assignments

It is possible to dynamically add new methods to a class. These methods are closures and can capture local variables in the context where they are created. It is not possible to specify names of these methods in the class declaration.

[expression/genitive] [method/e-infinitive active inessive] [parameter list] käyköön niin, että [statement list],
[expression] [method/e-infinitive passive inessive] [parameter list] käyköön niin, että [statement list],

If the verb is in passive voice, the case of the object can be anything. If it is in active voice, however, the the object must be in the genitive case.

For example:

nättiä nappia painettaessa käyköön niin, että kiva alue pyyhitään,
napakan neuronin lauetessa sähäkästä syötteestä käyköön niin, että napakan neuronin ulostuloksi asetetaan sähäkän syötteen summan neliöjuuri,

Expressions

Variables

Usually variables consist of an adjective and a noun.

kiva luku        # the nice number
lyhyt lista      # the short list
pieni vektori    # the small vector
loistava laskuri # the great counter
annettu pituus   # the given length
haluttu tulos    # the desired result

The special variable se is used to refer to the self object (this in JavaScript). It can also appear in form se itse (meaning "itself") when appearing as the object or predicative of a sentence where it is also the subject.

Luvun arvo on se itse. # the identity function

It is possible to create the variable when first using it.

[variable], joka on [expression/predicative],
[variable] [joka on [expression/predicative]]

Note that the second syntax has literal [] characters. When either of these is used, the variable is created and its value is set to the value of the expression.

It is also possible to initialize the variable to be a new object.

uusi [adjective] [noun]
[adjective] uusi [noun]

This is equivalent to [adjective] [noun], joka on uusi [noun],. All words must agree in case (be inflected in the same case).

Literal numbers

Literal numbers can appear in the code both written with digits or as words.

Olkoon pieni luku nolla.
Olkoon pieni luku 0.

There can be an optional unit noun after the number. If it is present, it must be inflected instead of the number. The noun is functionally a comment.

Olkoon nykyinen massa 10 kilogrammaa.

If the noun is inflected in anything else than nominative or partitive, the case of the noun will be the case of the expression. However, if the noun is inflected in partitive, the case of the expression will be nominative unless the number is also in partitive.

Literal strings

Literal strings are written inside "quotation marks".

Before a string literal there must be a noun that is inflected in the case that is the case of the string literal expression. The noun can be anything.

nykyinen sivu näyttää tekstin "Hello world!"
Olkoon kiva merkkijono lause "Hei maailma!".

The following escape codes are supported:

Function calls

There are two kinds of function calls in Tampio: genitive calls and essive calls.

In genitive calls, the argument is in the genitive case:

[argument/genitive] [function name]

For example:

viiden kertoma      # factorial(5)
neljän neliöjuuri   # sqrt(4)

The essive calls are typically used to convert a value to another type, form or representation. The function name is in the essive case and can appear either before or after the argument.

[argument] [function name/essive]
[argument] [function name/essive] [second argument]
[function name/essive] [argument]

If the function name is a past passive participle (ie. ending in -ttu/-tty), it can have an optional second argument, which can be in any case except nominative and genitive.

For example:

viisi merkkijonona                       # toString(5)
annettu luku pyöristettynä 4 desimaaliin # Math.round(this*10000)/10000

There is a small number of builtin essive functions that perform the basic mathematical operations of addition, subtraction, multiplication and division.

There are no parentheses in Tampio, so the operator precedence is defined using the list syntax. Two or more essive function calls can form an essive chain. It is not possible to use eikä muuta.

x jaettuna y:llä vähennettynä z:lla lisättynä w:hen     # x/(y-(z+w))
x jaettuna y:llä vähennettynä z:lla ja lisättynä w:hen  # x/((y-z)+w)
x jaettuna y:llä, vähennettynä z:lla ja lisättynä w:hen # ((x/y)-z)+w
x jaettuna y:llä ja vähennettynä z:lla lisättynä w:hen  # (x/y)-(z+w)

Object initialization

The uusi keyword is used to create new object. It is possible to optionally specify the initial values of the fields of the object.

uusi [type]
uusi [type], jonka [field assignment list],
[type], jonka [field assignment list],

Each field assignment has a field name and a value. The on keyword is used when the field name is singular and ovat when it is plural. If the field is an array, it is possible to initialize it using multiple values. In this case, the field name must be in plural partitive case.

[field name/nominative] on [predicative]
[field name/partitive] ovat [predicative list]

Examples:

uusi vektori
uusi vektori, jonka komponentit ovat villin vektorin komponentit eikä muuta,
vektori, jonka komponentteja ovat pieni luku, suuri luku ja nolla eikä muuta,

Array subscript

If the array is in a field inside an object or a return value of a function, the following syntax is used.

[object/genitive] [ordinal] [field name or function name/singular]

If the array is instead a variable, the following is used.

[ordinal] [array object]

The name of the array (which usually is plural), must be singular in this expression.

For example:

villin vektorin neljäs komponentti  # villi_vektori.komponentti[4]
nätin luvun toinen potenssi         # nätti_luku.potenssi[2] = nätti_luku^2
n:s luku                            # luku[n]

The available ordinal literals are listed below. It is also possible to use single-letter variables.

If the ordinal is jokainen, the current statement is a for statement (see the Statements chapter).

Array slice

The slice syntax is used to retrieve a subarray that contains only the elements that are in a specific range.

[array object] [ordinal/elative] alkaen
[array object] [ordinal/illative] päättyen
[array object] [ordinal/elative] alkaen [ordinal/illative] päättyen

The ordinal before alkaen is the start index and the ordinal before päättyen is the end index.

Ternary expression

A ternary expression contains two subexpressions and evaluates one of them depending on the truth value of the condition.

riippuen siitä, [condition expression], joko [expression] tai [expression]

joko is a keyword that can be used in place of eikä muuta when there is only one condition.

Conditions must be in one of these forms:

onko [expression] [operator] [expression]
eikö [expression] ole [operator] [expression]

The operators are as in if statements, see the table in the If statements chapter. Multiple conditions can be connected using logical connectives ja, tai, sekä and taikka.

Compiler imperatives

There is a small number of special commands called "compiler imperatives". They are marked by verbs that are inflected in the imperative mood, hence the name.

Top-level imperatives

These imperatives can be used at the top-level along with the definitions.

Salli/Kiellä

These imperatives are used to enable and disable compiler features.

Available options:

Sisällytä

This imperative is used to include code in the program. It can be used to include Tampio files, target code and target code files.

Sisällytä tiedosto "[filename]".
Sisällytä kohdekoodi "[code]".
Sisällytä kohdekooditiedosto "[filename]".

Tulkitse

This imperative is used to create a type alias. It can also be used to give a target code class a name in Tampio.

Tulkitse [alias name/nominative] [target name/essive].
Tulkitse [alias name/nominative] kohdekoodityyppinä "[target code type]".

Statement-level imperatives

These imperatives work like usual statements.

suorita

This imperative compiles to the given target code.

suorita kohdekoodi "[code]"

Expression-level imperatives

These imperatives are exceptionally not in the imperative mood.

kohdekoodina

This imperative compiles to the given target code.

koodi "[code]" kohdekoodina

Standard library

Object class

The object class does not have a name in Tampio, and is the JavaScript class Object. It is the super class of other classes.

Pseudodeclaration:

Kun kiva "object" kirjataan lokiin, ...

Array class

The array class does not have a name in Tampio, and is the JavaScript class Array.

All plural fields have this type. The difference between this type and the lista class is both syntactic and semantic. Arrays are seen as multiple values, whereas lists are single values that contain values. Therefore, it is not meaningful to talk about "a single array" or "many arrays", as the array type is not countable. Indeed, it is not possible to create an array of arrays in Tampio, because array is not a single value and it cannot be contained otherwise than as a field or a variable. Lists of lists are possible.

Pseudodeclaration:

"Arrayn" määrä on ...
"Arrayn" summa on ...

Kun kivaksi "arrayksi" lisätään kiva arvo, ...

ajankohta class

ajankohta is an alias to the JavaScript class Date.

Pseudodeclaration:

Ajankohdalla on vuosi, kuukausi, päivä, tunti, minuutti, sekunti.

Ajankohta millisekunteina on ...

Ajankohta merkkijonona on ...
Ajankohta päivämäärämerkkijonona on ...
Ajankohta kellonaikamerkkijonona on ...

elementti class

elementti is the JavaScript class HTMLElement.

Pseudodeclaration:

Kun kivalle "elementille" kirjoitetaan annettu teksti, ...
Kun kiva "elementti" pyyhitään, ...

Function class

The function class does not have a name in Tampio, and is the JavaScript class Function.

Pseudodeclaration:

Kun kiva "funktio" suoritetaan, ...

lista class

Declaration:

Listalla on alkiot.

Listan koko on sen alkioiden määrä.
Listan häntä on uusi lista, jonka alkiot ovat sen alkiot toisesta alkaen.

Lista järjestettynä on ...
Kun lyhyt lista järjestetään, ...

Lista on tyhjä, jos sen alkioiden määrä on nolla.

Kun lyhyt lista etsii indeksin ihanalle alkiolle, ...
Kun lyhyeen listaan lisätään ihana alkio, ...
Kun lyhyestä listasta poistetaan ihana alkio, ...

luku class

luku is an alias to the JavaScript class Number.

Pseudodeclaration:

Luvun potenssit ovat ...
Luvun neliö on ...
Luvun kuutio on ...

Luvun neliöjuuri on ...
Luvun kuutiojuuri on ...

Luvun vastaluku on ...
Luvun käänteisluku on ...

Luvun edeltäjä on ...
Luvun seuraaja on ...

Luvun itseisarvo on ...
Luvun merkki on ...

Luvun sini on ...
Luvun kosini on ...
Luvun tangentti on ...

Luvun logaritmi on ...
Luvun vastalogaritmi on ...

Luvun kertoma on ...

Luvun tekijät ovat ...
Luvun alkutekijät ovat ...

Luku kokonaislukuna on ...
Luku pyöristettynä on ...
Luku pyöristettynä annettuun tarkkuuteen on ...

Luku merkkijonona on ...
Luvun merkkijonoesitys on ...

merkkijono class

merkkijono is an alias to the JavaScript class String.

Pseudodeclaration:

Merkkijonon pituus on ...

Merkkijonon merkit ovat ...
Merkkijonon sanat ovat ...
Merkkijonon kentät ovat ...
Kun mukava merkkijono jaetaan annetusta erottimesta kivoiksi arvoiksi, ...

Merkkijono siistittynä on ...

Kun mukava merkkijono näytetään käyttäjälle, ...
Kun mukava merkkijono tulostetaan lokiin, ...

Merkkijono merkkijonona on se itse.
Merkkijonon merkkijonoesitys on se itse.

muuttuja class

Muuttujalla on arvo.
Kun mukavaan muuttujaan luetaan luku, ...

määrä class

määrä is an alias to luku, which in turn is an alias to JavaScript class Number.

Promise class

The promise class does not have a name in Tampio, and is the JavaScript class Promise.

sivu class

sivu is an alias to the JavaScript class HTMLDocument.

Pseudodeclaration:

Kun nykyinen sivu näyttää mielenkiintoisen tekstin, ...
Kun nykyinen sivu etsii elementin annetulla nimellä, ...

Finnish-English mini dictionary

Finnish declension

In Finnish nouns are inflected in cases. There are a few of them, listed below. The exact meanings of the cases are not important to understand the programming language.

The inflection of nouns is a pretty complicated process. The exact suffix depends on vowel harmony ("A" is either "a" or "ä") and the stem of the word can change due to consonant gradation. It is outside the scope of this document to describe declension further. Inflected forms of different words can be checked from Wiktionary if needed.

Finnish conjugation

Finnish verb conjugation is very complicated. In Tampio, only some of the forms are used.

In the table below, the verbs lisätä (to add) and tulostaa (to print) are conjugated in the relevant forms.

License

The Tampio Compiler is licensed under the GNU General Public License, version 3 or later. This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. See the LICENSE file for details.

The examples are dual licensed under the MIT license and the Finnish translation of the MIT license (FTM license).