Kotlin (programmeertaal)

Kotlin
Bestand:Kotlin-logo.png
Paradigma	Multi-paradigma: functioneel, objectgeorienteerd, Imperatief programmeren
Verschenen in	2011
Ontworpen door	Andrey Breslav
Ontwikkeld door	JetBrains en open source contributors
Huidige versie	1.1.2
Typesysteem	statisch, sterk met type-inferentie
Bestandsextensies	.kt, .kts

Kotlin is een statisch getypeerde multiplatform-programmeertaal, die probeert volledig interoperabel te zijn met de taal van het platform.

Kotlin is ontwikkeld door JetBrains, dat gevestigd is in Sint-Petersburg en vernoemd naar het nabijgelegen eiland Kotlin.

Filosofie

Het oorspronkelijke doel van Kotlin is om een object georiënteerd taal te zijn, die "beter" is dan Java, maar toch volledig interoperabel met Java. Hierdoor kunnen bedrijven een geleidelijke overstap maken naar Kotlin, aldus Andrey Breslav (hoofdingenieur van JetBrains).

Sinds 2017 is het doel van Kotlin verbreed en wil het een multiplatform taal zijn die compileert naar de native talen van het platform, en hierdoor compatibel is met die talen.

Platforms

De Kotlin-API is opgesplitst in twee onderdelen:

de common modules en de platform specifieke modules.

In de common modules zitten de onderdelen die vanaf elk platform te gebruiken zijn en de platform-gerelateerde onderdelen zitten in de platform-specifieke onderdelen.

Wanneer iets dus geschreven is met alleen de common modules, dan kan dit worden gecompileerd naar elk platform.

Java Virtual Machine

De door Kotlin geproduceerde bytecode draait op de Java Virtual Machine. Hierbij kan worden gekozen tussen Java 6 en Java 8.

Voor de implementatie van de common modules wordt gebruik gemaakt van de Java Class Library en de Java Collections Framework.

Om te compileren is sinds versie 1.1.2 JDK8 nodig.

Android

Op 17 mei 2017 heeft Android Kotlin als officiële programmeertaal toegevoegd.

De bekendste kotlin-framework voor Android is Anko, die ontwikkeld is door Jetbrains.

Javascript

Kotlin/JavaScript wordt getranspileerd naar JavaScript. Momenteel is dat ECMAScript 5.1.

Daarnaast kan TypeScript definities naar Kotlin declaraties worden geconverteerd met ts2kt.

Native

Met de LLVM compiler wordt code direct naar machinecode vertaald. Het Native project is nog in een previewstadium.

De platformen die worden ondersteund omvatten:

• Mac OS X 10.10 and later (x86-64)
• x86-64 Ubuntu Linux (14.04, 16.04 and later), other Linux flavours may work as well
• Apple iOS (arm64), cross-compiled on MacOS X host
• Raspberry Pi, cross-compiled on Linux host

Kotlin/Native kan interfacen met in C geschreven functies.

Syntaxis

In Kotlin komt het datatype na de naam van de variabelen en parameters. Daarnaast is de puntkomma om een statement af te sluiten niet verplicht; meestal is een nieuwe regel voor de compiler al genoeg.

Semantiek

Kotlin ondersteunt het Object Georiënteerd programmeren door middel van klassen en methodes, maar de methodes kunnen ook worden gebruikt buiten de klassen, waardoor imperatief programmeren met functies ook mogelijk is. Een programma begint net als Java met de functie main met als parameter een array met command-line-argumenten. Type-inferentie is ook mogelijk.

Hello world! voorbeeld:<syntaxhighlight lang="kotlin"> fun main(args: Array<String>) {

   val scope = "world"
   println("hello, $scope")

} </syntaxhighlight>

Nullable types

Kotlin maakt verschil tussen nullable types en niet-nullable types. alle Nullable types moeten eindigen met een "?":<syntaxhighlight lang="kotlin"> val nullString: String? = null //werkt, want is nullable val notNullString: String = null //werkt niet want is niet nullable </syntaxhighlight>Voor elke aanroep op een nullable type moet worden gekeken of de type null is.

In Kotlin zijn hier twee operatoren voor:

• ?. (veilige-navigatie-operator): Hij geeft null terug als de operand null is en hij voert anders de code achter de operator uit.
• ?: (Elvis-operator) : geeft de waarde voor de operator als die niet null is, anders geeft hij de waarde achter de operator.

Voorbeeld van de veilige-navigatie-operator:<syntaxhighlight lang="kotlin"> // geeft null als foo of bar null zijn en geeft anders de teruggeefwaarde van baz foo ?. bar() ?. baz() </syntaxhighlight>Voorbeeld van de Elvis-operator<syntaxhighlight lang="kotlin"> fun welkom(naam: String?){

   val welkomNaam = naam ?: "vreemdeling"

}

fun main(args : Array<String>){

   println(welkom(null)) // print "welkom vreemdeling"
   println(welkom("gebruiker")) // print "welkom gebruiker"

}

</syntaxhighlight>Om dependency injection mogelijk te maken zonder een nullable type te gebruiken, kan er gebruikt worden gemaakt van lateinit.

Coroutines

Coroutines is Kotlins manier voor multithreading. Het opvallende is dat Kotlin hier maar een keywoord voor gebruikt: Suspend.

Daarnaast wordt er veel gedaan met compiler-magic, waardoor de coroutines veel lichter zijn dan threads.

Op dit moment zijn de coroutines nog in de experimentele fase.

DSL builders

Een van de opvallende regels van Kotlin zijn DSL-builders. Hiermee kan een DSL worden gemaakt.

DSL (Domain specific language) is een taal die ontwikkeld is voor bepaalde domeinen.

Deze DSL-functies bestaan uit extensie-functies en regels voor lambda's die gecombineerd de extensie-lambda vormen.

Extensie-functies

Kotlin kent het concept extensie-functies. Dit zijn functies die een al bestaande klasse kunnen uitbreiden.

Voorbeeld van extensie-functies:<syntaxhighlight lang="kotlin"> class RekenMachine{

   fun keer(a: Int, b: Int)  : Int{
       return a * b
   }

}

//voegt keer5 aan RekenMachine toe fun RekenMachine.keer5(a: Int, b: Int){

   this.keer(5, a)
   // we zitten in de RekenMachine, dus this is de RekenMachine
   
   // maar dit mag worden weggelaten dus:
   keer(5, a)

}

fun main(args : Array<String>){

   // hier wordt een nieuw RekenMachine aangemaakt
   // (de "new" van Java moet in Kotlin worden weggelaten)
   // en keer op aangeroepen
   RekenMachine().keer5(3) // antwoord: 15

} </syntaxhighlight>

Lambda's

Lambda is de naam voor een functie-datatype.In Kotlin, wordt een lambda geschreven als (parameter, parameter) -> returnType. Wanneer lambda's als laatste parameter worden meegegeven aan een functie, mag hij achter de functie worden neergezet. Bovendien mogen als er achter een functie-aanroep wordt gedaan, zonder parameters, mogen de haakjes weggehaald worden.

Voorbeeld met meerdere parameters:<syntaxhighlight lang="kotlin"> // deze functies wil drie parameters // - een integer // - een lambda die een integer vraagt en een integer teruggeeft fun keer(a: Int, keer: (Int)->Int) : a {

   return keer(a) // voert de lambda uit op de twee gekregen integers

}

fun main(args: array<String>){

   // lambda opgeslagen in veriabele
   val keer5 = {a -> a * 5}
   keer(3, keer5) // is 15
   
   //lambda direct als parameter
   keer(3, {a -> a * 5})
   
   //lambda achter de functie
   keer(3) {
       a -> a * 5
   }

} </syntaxhighlight>Voorbeeld met een parameter:<syntaxhighlight lang="kotlin"> // Unit (void in Java) // vraagt een lambda zonder parameters die Unit (niks) teruggeeft class Rekenmachine{

   var a = 3
   
   fun keer(exec: ()-> int): Int{
       return exec()
   }

}

fun main(args: Array<String>){

   //lambda opgeslage in variabele
   val keer5 = {
       Rekenmachine.a * 5
   }
   keer(keer5)
   
   //lambda meegegeven als parameter
   keer({
       Rekenmachine.a * 5
   }) 
   
   //lambda achter de functie
   keer(){
       Rekenmachine.a * 5
   }
   
   // er zijn geen parameters tussen de haakjes,dus de haakjes mogen weg
   keer{
       Rekenmachine.a * 5
   }

} </syntaxhighlight>

Extensie-lambda's

In Kotlin heb je niet alleen extensie-functies maar ook extensie-lambda's. Deze worden meegegeven als een parameter:<syntaxhighlight lang="kotlin"> class Rekenmachine{

   var a: Int = 3
   fun keer(exec: ()-> int) : Int {
       return exec();
   }

}

// Rekenmachine.() vraagt om een extension-lambda, die een int returnt fun bereken(berekening: Rekenmachine.()->Int) : Int{

   val rm: Rekenmachine = Rekenmachine() //maak Rekenmachine aan.
   return lambda(rm) // geef rm aan de lambda

}

fun main(args: Array<String>) {

   //zonder extension-lambda zie vorig voorbeeld
   Rekenmachine().keer{
       Rekenmachine.a * 5
   }
   
   
   
   
   bereken(//hieronder begint de extension-lambda:
       {//this wijst naar rekenmachine, want we zitten in rekenmachie
           this.keer{
               this.a * 5
           }
       }
   )
   
   bereken(//hieronder begint de extension-lambda:
       {//this mag worden weggelaten
           keer{a * 5}
       }
   )
   
   // de extension-lambda was de laatste parameter,dus hetvolgende maag ook:
   bereken{
       keer{a * 5}
   }
   
   // keer geeft 3 * 5 = 15 terug en bereken geeft die door.
   val ans = bereken{
       keer{a*5}
   }

} </syntaxhighlight>

Bronnen, noten en/of referenties

Bronnen, noten en/of referenties