Scala vs Kotlin¶

class Person(val name:String, var age:Int = 0)

class Person(val name:String, var age:Int = 0)

class Person(var name: String, var age: Int = 0) extends Ordered[Person] {

  def sayHi(): String = {
    "Hi"
  }

  override def compare(other: Person): Int = age - other.age

  def +(lifetime: Int): Person = {
    age += lifetime
    this
  }
}

object Person {
  def newBorn(name:String) = new Person(name, 0)
  def apply() = new Person("John Doe", -1)
}

class Person(var name: String, var age: Int = 0): Comparable<Person> {

  fun sayHi(): String {
    return "Hi"
  }

  operator fun plus(lifetime: Int): Person {
    age += lifetime
    return this
  }

  override operator fun compareTo(p: Person) = age - p.age

  companion object {
    fun newBorn(name:String) = Person(name)
    operator fun invoke() = Person("John Doe")
  }
}

class Species(val kind:String) {
  def eats:Seq[String] = Seq()
}

class Person(val name:String, var age:Int) extends Species("Homo Sapiens") {
  override def eats:Seq[String] = Seq("...")
}

open class Species(val kind:String) {
  open fun eats():List<String> = emptyList()
}

class Person(val name:String, var age:Int = 0):Species("Homo Sapiens") {
  override fun eats():List<String> = listOf("...")
}

case class Person(name:String, var age:Int = 0)

data class Person(val name:String, var age:Int = 0)

val jack = Person("Jack", 42)
// jack: Person(name=Jack, age=32)

jack == Person("Jack", 42)
// res1: true

val fred = jack.copy(name = "Fred")
// fred: Person(name=Jack, age=32)

def doWithText(path: File, transFun: (String) => String): String =
  transFun(FileUtils.readFileToString(path))

doWithText(new File("/news.txt"), txt => txt.toUpperCase())
doWithText(new File("/news.txt"), _.toUpperCase())


def writeToFile(file: File, block: => String) {
  if (file.isFile) FileUtils.writeStringToFile(file, block)
}

writeToFile(new File("/srocks.txt"), "Scala rocks! " * 1000)

fun doWithText(path: File, transFun: (String) -> String): String =
  transFun(FileUtils.readFileToString(path))

// On the call-side a function must be wrapped within {}
doWithText(File("/text.txt")){ txt -> txt.toUpperCase() }

// it serves as placeholder of the function parameter.
doWithText(File("/text.txt")){ it.toUpperCase() }

// Kotlin supports no-argument functions, similar to Scala’s call-by name arguments
fun writeToFile(file:File, block: () -> String) {
  if(file.isFile)FileUtils.writeStringToFile(file, block())
}

// On the call-side the empty argument and arrow can be omitted
writeToFile(File("/krocks.txt")){"Kotlin rocks! ".repeat(1000)}

def modN(n: Int)(x: Int) = ((x % n) == 0) 
val modTwo = modN(2)(_)
Seq(1,2,3) filter modTwo

val greaterThan100 = Math.max(100, _:Int) 
greaterThan100(200)

trait Function1[-T1, +R] extends AnyRef {
  def apply(v1: T1): R
}

interface Function1<in P1, out R> : Function<R> {
  operator fun invoke(p1: P1): R
}

type IntToStringFun = Function1[Int, String]

typealias IntToStringFun = Function1<Int, String>

case class Booking(destination: Option[Destination] = None)
case class Destination(hotel: Option[Hotel] = None)
case class Hotel(name: String, stars: Option[Int] = None)

// The functional approach 

val bOpt = Some(Booking(Some(Destination(Some(Hotel("Sunset Paradise", Some(5)))))))

var stars = "*" * bOpt.flatMap(_.destination).flatMap(_.hotel).flatMap(_.stars).getOrElse(0)

// or `for` expressions can be used to access optional values
stars = "*" * (for {
  booking <- bOpt
  dest <- booking.destination hotel <- dest.hotel
  stars <- hotel.stars
} yield stars).getOrElse(0)

class Booking(val destination:Destination? = null)
class Destination(val hotel:Hotel? = null)
class Hotel(val name:String, val stars:Int? = null)

val booking:Booking? = Booking(Destination(Hotel("Sunset Paradise", 5))) 

// To safely access nullable types the ? can be used with ?: for the alternative case.
val stars = "*".repeat(booking?.destination?.hotel?.stars ?: 0) //-> "*****"

//  After checking for not null a type is ‘smart casted’ to its non-null type: here from Booking? to Booking
if(booking != null) {
  println(booking.destination)
}

def matchItAll(p: Any): Any = {
  p match {
    case x: Int                       => s"$x"            // (1)
    case "Scala"                      => "Scala"          // (2)
    case Seq(_, 3, _*)                => "Seq(?, 3, *)"   // (3)
    case head :: tail                 => s"$head $tail"   // (4)
    case (firstEl, _)                 => s"$firstEl"      // (5)
    case Some(s:Long)                 => s"Some Long $s"  // (6)
    case x: Int if 1 to 10 contains x => s"$x"            // (7)
    case x: String if x.endsWith("!") => s"$x"            // (8)
    case _                            => "The default"    // (9)
  }
}

fun matchItAll(p:Any?):Any =
  when(p) {
    is Int -> "$p" // Smart case to Int  // (1) ✅
    "Kotlin" -> "Kotlin"                 // (2) ✅
    // N/A                               // (3) ❌
    // N/A                               // (4) ❌
    Pair("literal", "only") -> "..."     // (5) ️️️🔶
    is Long? -> "null or Long"️           // (6) 🔶
    in 1..10 -> "Value in 1..10"         // (7) 🔶
    //                                   // (8) 🔶
    else -> "The default"                // (9) 🔶

fun matchItAll(p:Any?):Any = when {
  p is String && p.endsWith("!") ->"$p"
  else -> "The default" // No smart cast
}

case class Person(name:String, age:Int)
val john = Person("John", 42)
val Person(name, age) = john

// ...

object Person {
  def unapply(person: Person): Option[(String, Int)] =
    Some((person.name, person.age))
}

data class Person(val name:String, val age:Int)
val john = Person("John", 42)
val (name, age) = john // // Kotlin support destructuring too.

john.component1() //-> John
john.component2() //-> 45

// ...
fun component1() = name
fun component2() = age

abstract class Ship(var health: Int = 100)

trait Gun {
  val strength: Int = 1
  def fireAt(ship: Ship) = { ship.health -= (1 * strength) }
}

trait Medic {
  val lives: Int = 10
  def repair(ship: Ship) = { ship.health += lives }
}

class Commander extends Ship() with Gun with Medic {
  val info = s"Gun strength: $strength, Medic capacity: $lives"
}

val commander = new Commander()
commander.fireAt(...)
commander.strength            //-> 1
commander.isInstanceOf[Gun]   //-> true
commander.isInstanceOf[Medic] //-> true

abstract class Ship(var health:Int = 100)

interface Gun {
  val strength:Int
  fun fireAt(ship: Ship) { ship.health =- (1 * strength) } 
}

interface Medic {
  val lives:Int
  fun repair(ship:Ship) { ship.health =+ lives } 
}

class LazerGun(override val strength: Int = 5) : Gun
class MinorRepair(override val lives: Int = 10) : Medic
class Commander(gun:Gun, repair:Medic): Ship(), Gun by gun, Medic by repair

val commander = Commander(LazerGun(), MinorRepair())
commander.fireAt(...)

// yielding more or less the same results like traits
commander.strength // -> 5
commander is Gun   // -> true
commander is Medic // -> true

implicit class RichInt(val value:Int) extends AnyVal {
  def square = value * value
}

2.square //-> 4

// this refers to the instance of the extended class
fun Int.square(): Int = this * this

2.square() //-> 4

listOf(1,2,3).sum()  // Convenience methods on Collections

listOf("a", "a", "a").map{it.toUpperCase()}  // Higher-Order Functions

"hi".reversed() // Convenience methods on Collections

File("/tmp.txt").useLines {
  lines -> lines.joinToString(" ") // Loans on IO APIs
}

val x:Int? = null
x?.let{ it * it} ?: -1 // counterpart of Scala’s Option.map(...)

class PersonBuilder(var name:String? = null, var age:Int? = null) {
  fun toPerson() = Person(name ?: "John Doe", age ?: 0)
}

// Function Types with Receiver
// read like: when invoking create() on PersonBuilder, the builder instance is provided
fun person(create:PersonBuilder.() -> Unit):Person {
  val builder = PersonBuilder()
  builder.create()
  return builder.toPerson()
}

person {
  name = "Super Trooper"
  age = 42
}

router { 
  accept(TEXT_HTML).nest {
    GET("/") { ok().render("index") }
    GET("/sse") { ok().render("sse") }
    GET("/users", userHandler::findAllView)
  }
  "/api".nest {
    accept(APPLICATION_JSON).nest {
      GET("/users", userHandler::findAll)
    }
  accept(TEXT_EVENT_STREAM).nest {
    GET("/users", userHandler::stream) }
  }
  resources("/**", ClassPathResource("static/"))
}

// (1) Immutable coll. (default)
val l = Seq(1,2,3)
val l2 = l :+ 4
// l -> 1,2,3
// l 2 -> 1,2,3,4

// (2) Mutable coll.
val ml = ListBuffer(1,2,3)
ml :+ 4
// ml -> 1,2,3,4

// (3) Ranges
(1 to 3).map(_ + 1)

// (4) Higher Order functions
Map("a" -> 1).forall(_._2 > 10)
// true

// (5) Advanced methods
List(1,2,3).sliding(2)
// List(List(1,2), List(2,3))

// (6) Conversion from coll. X->Y
Set("a" -> 1).toMap

// (7) Union
List(1,2) ++ List(3,4)
//1,2,3,4

// (1) Immutable coll. (default)
val l = listOf(1,2,3)
val l2 = l + 4
// l -> 1,2,3
// l2 -> 1,2,3,4

// (2) Mutable coll.
val ml = mutableListOf(1,2,3)
ml + 4
//ml -> 1,2,3,4

// (3) Ranges
(1..3).map{it + 1}

// (4) Higher Order functions
mapOf("a" to 1).all{it.value > 10}
// true

// (5) Advanced methods
listOf(1,2,3).windowed(2)
// List(List(1,2), List(2,3))

// (6) Conversion from coll. X->Y
setOf("a" to 1).toMap()

// (7) Union
listOf(1,2) + listOf(3,4)
// 1,2,3,4

def temperatureIn(city: String):Int = Random.nextInt(30)
val ams = temperatureIn("Amsterdam")
val zrh = temperatureIn("Zurich")
println(s"AMS: ${ams} ZRH: ${zrh}")
//AMS: 24 ZRH: 26

def temperatureIn(city: String):Future[Int] = Future{
  Thread.sleep(1000)
  Random.nextInt(30)
}

val amsFuture = temperatureIn("Amsterdam")
val zrhFuture = temperatureIn("Zurich")
// Since they are libraries - and not language features -
// they force you to tightly bind your code to their API and abstractions.
val temperatures = amsFuture.flatMap(ams =>
  zrhFuture.map(zrh => s"AMS: ${ams} ZRH: ${zrh}")
)

println(Await.result(temperatures, 5 seconds))
//AMS: 24 ZRH: 26

// A method marked suspend can be run within a coroutine that can suspend it without blocking a Thread
suspend fun temperatureIn(city: String): Int {
  delay(1000)
  return Random().nextInt(30)
}

// To start a coroutine at least one suspending function is required (here async)
val ams = async { temperatureIn("Amsterdam") }
val zrh = async { temperatureIn("Zurich") }

// await suspends the coroutine until some computation is done and returns the result
println("AMS: ${ams.await()} ZRH: ${zrh.await()}")
//AMS: 24 ZRH: 26

suspend fun temperatureIn(city: String): Int {
  delay(1000)
  return Random().nextInt(30)
}

// Java
Object temperatureIn(String city, Continuation<Int> cont){...}

public interface Continuation<in T> {
  public val context: CoroutineContext
  public fun resume(value: T)
  public fun resumeWithException(exception: Throwable)
}

public CompletableFuture<Integer> temperatureIn(String city) {
  return CompletableFuture.supplyAsync(() -> {
   return new Random().nextInt(30);
   });
}

suspend fun <T> CompletableFuture<T>.await(): T =
  suspendCoroutine<T> { cont: Continuation<T> ->
    whenComplete { result, exception ->
      if (exception == null) // the future has been completed normally
        cont.resume(result)
      else // the future has completed with an exception
        cont.resumeWithException(exception)
    }
  }