Kotlin (programming language)

1 // Hello, World! example
2 fun main(args: Array<String>) {
3   val scope = "World"
4   println("Hello, $scope!")
5 }

1     package MyStringExtensions
2 
3     fun String.lastChar(): Char = get(length - 1)
4 
5     >>> println("Kotlin".lastChar())

1     // Overloading '+' operator using an extension method
2     operator fun Point.plus(other: Point): Point {
3         return Point(x + other.x, y + other.y)
4     }
5 
6     >>> val p1 = Point(10, 20)
7     >>> val p2 = Point(30, 40)
8     >>> println(p1 + p2)
9     Point(x=40, y=60)

1     fun main(args: Array<String>) { 
2         val list = listOf("args: ", *args)
3         println(list)
4     }

1     for ((index, element) in collection.withIndex()) { 
2          println("$index: $element")
3     }

 1     class User(
 2         val id:      Int, 
 3         val name:    String, 
 4         val address: String) 
 5     {
 6 
 7         fun saveUser(user: User) {
 8            fun validate(user: User, value: String, fieldName: String) {
 9                if (value.isEmpty()) {
10                    throw IllegalArgumentException(
11                       "Can't save user ${user.id}: empty $fieldName")
12                }
13            }
14 
15            validate(user, user.name, "Name") 
16            validate(user, user.address, "Address")
17            // Save user to the database
18         }
19     }

 1     // open on the class means this class will allow derived classes
 2     open class MegaButton  {
 3 
 4         // no-open on a function means that 
 5         //    polymorphic behavior disabled if function overridden in derived class
 6         fun disable() { ... }
 7 
 8         // open on a function means that
 9         //    polymorphic behavior allowed if function is overridden in derived class
10         open fun animate() { ... }
11     }
12 
13     class GigaButton: MegaButton {
14 
15         // Explicit use of override keyword required to override a function in derived class
16         override fun animate() { println("Giga Click!") } 
17     }

 1     // No need for the open keyword here, its already open by default
 2     abstract class Animated {
 3 
 4         // This virtual function is already open by default as well
 5         abstract fun animate()
 6   
 7         open fun stopAnimating() { }
 8 
 9         fun animateTwice() { }
10     }

1     // Class is visible only to current module
2     internal open class TalkativeButton : Focusable {
3         // method is only visible to current class 
4         private   fun yell() = println("Hey!")
5 
6         // method is visible to current class and derived classes
7         protected fun whisper() = println("Let's talk!")
8     }

1      // Example of class using primary constructor syntax
2      // (Only one constructor required for this class)
3      class User(
4          val nickname: String, 
5          val isSubscribed: Boolean = true) 
6      {
7          ...
8      }

 1     // Example of class using secondary constructor syntax
 2     // (more than one constructor required for this class)
 3     class MyButton : View {
 4 
 5         // Constructor #1 
 6         constructor(ctx: Context) : super(ctx) { 
 7             // ... 
 8         } 
 9   
10         // Constructor #2
11         constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) { 
12             // ... 
13         }
14     }

1         fun Activity.showAreYouSureAlert(process: () -> Unit) {
2             alert(
3               title   = "Are you sure?",
4               message = "Are you really sure?") 
5             {
6               positiveButton("Yes") { process() }
7               negativeButton("No") { cancel() }
8             }
9         }

$ kotlinc-jvm
type :help for help; :quit for quit
>>> 2+2
4
>>> println("Hello, World!")
Hello, World!
>>>

1 // list_folders.kts
2 import java.io.File
3 val folders = File(args[0]).listFiles { file -> file.isDirectory() }
4 folders?.forEach { folder -> println(folder) }

1 $ kotlinc -script list_folders.kts "path_to_folder_to_inspect"

 1 fun main(args: Array<String>) {
 2     
 3     greet {
 4         to.place
 5     }.print()
 6 }
 7 
 8 // Inline higher-order functions
 9 inline fun greet(s: () -> String) : String = greeting andAnother s()
10 
11 // Infix functions, extensions, type inference, nullable types, 
12 // lambda expressions, labeled this, Elvis operator (?:)
13 infix fun String.andAnother(other : Any?) = buildString() 
14 { 
15     append(this@andAnother); append(" "); append(other ?: "") 
16 }
17 
18 // Immutable types, delegated properties, lazy initialization, string templates
19 val greeting by lazy { val doubleEl: String = "ll"; "he${doubleEl}o" }
20 
21 // Sealed classes, companion objects
22 sealed class to { companion object { val place = "world"} }
23 
24 // Extensions, Unit
25 fun String.print() = println(this)

fun sayHello(maybe: String?, neverNull: Int) {
   // use of elvis operator
   val name: String = maybe ?: "stranger"
   println("Hello $name")
}

  // returns null if...
  // - foo() returns null,
  // - or if foo() is non-null, but bar() returns null,
  // - or if foo() and bar() are non-null, but baz() returns null.
  // vice versa, return value is non-null if and only if foo(), bar() and baz() are non-null
  foo()?.bar()?.baz()

  // the following function takes a lambda, f, and executes f passing it the string, "lambda"
  // note that (s: String) -> Unit indicates a lambda with a String parameter and Unit return type
  fun executeLambda(f: (s: String) -> Unit) {
    f("lambda")
  }

  // the following statement defines a lambda that takes a single parameter and passes it to the println function
  val l = { c : Any? -> println(c) }
  // lambdas with no parameters may simply be defined using { }
  val l2 = { print("no parameters") }