print("Hello, world!")

println("Hello, world!")

console.log("Hello, world!")

var myVariable = 42
myVariable = 50
let myConstant = 42

var myVariable = 42
myVariable = 50
val myConstant = 42

let myVariable = 42
myVariable = 50
const myConstant = 42

let explicitDouble: Double = 70

val explicitDouble: Double = 70.0

// nope

let label = "The width is "
let width = 94
let widthLabel = label + String(width)

val label = "The width is "
val width = 94
val widthLabel = label + width

let label = "The width is "
let width = 94
let widthLabel = label + width

let apples = 3
let oranges = 5
let fruitSummary = "I have \(apples + oranges) " +
                   "pieces of fruit."

val apples = 3
val oranges = 5
val fruitSummary = "I have ${apples + oranges} " +
                   "pieces of fruit."

let apples = 3
let oranges = 5
let fruitSummary = `I have ${apples + oranges} ` +
                   "pieces of fruit."

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("Person \(i + 1) is called \(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

val names = arrayOf("Anna", "Alex", "Brian", "Jack")
val count = names.count()
for (i in 0..count - 1) {
    println("Person ${i + 1} is called ${names[i]}")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

// nope

for index in 1...5 {
    print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

for (index in 1..5) {
    println("$index times 5 is ${index * 5}")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

// nope

var shoppingList = ["catfish", "water",
    "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

val shoppingList = arrayOf("catfish", "water",
    "tulips", "blue paint")
shoppingList[1] = "bottle of water"

let shoppingList = ["catfish", "water",
    "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

val occupations = mutableMapOf(
    "Malcolm" to "Captain",
    "Kaylee" to "Mechanic"
)
occupations["Jayne"] = "Public Relations"

let occupations = {
    "Malcolm": "Captain",
    "Kaylee": "Mechanic"
}
occupations["Jayne"] = "Public Relations"

let emptyArray = [String]()
let emptyDictionary = [String: Float]()

val emptyArray = arrayOf<String>()
val emptyMap = mapOf<String, Float>()

let emptyArray = []
let emptyDictionary = {}

func greet(_ name: String,_ day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")

fun greet(name: String, day: String): String {
    return "Hello $name, today is $day."
}
greet("Bob", "Tuesday")

function greet(name, day) {
    return `Hello ${name}, today is ${day}.`
}
greet("Bob", "Tuesday")

func getGasPrices() -> (Double, Double, Double) {
    return (3.59, 3.69, 3.79)
}

data class GasPrices(val a: Double, val b: Double,
     val c: Double)
fun getGasPrices() = GasPrices(3.59, 3.69, 3.79)

function getGasPrices() {
  return [3.59, 3.69, 3.79]
}
let [first, second, third] = getGasPrices()

func sumOf(_ numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf(42, 597, 12)

fun sumOf(vararg numbers: Int): Int {
    var sum = 0
    for (number in numbers) {
        sum += number
    }
    return sum
}
sumOf(42, 597, 12)

function sumOf(...numbers) {
    let sum = 0
    for (let i in numbers) {
        sum += numbers[i]
    }
    return sum
}
sumOf(42, 597, 12)

func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
let increment = makeIncrementer()
increment(7)

fun makeIncrementer(): (Int) -> Int {
    val addOne = fun(number: Int): Int {
        return 1 + number
    }
    return addOne
}
val increment = makeIncrementer()
increment(7)

// makeIncrementer can also be written in a shorter way:
fun makeIncrementer() = fun(number: Int) = 1 + number

function makeIncrementer() {
    let addOne = function(number) {
        return 1 + number
    }
    return addOne
}
let increment = makeIncrementer()
increment(7)

let numbers = [20, 19, 7, 12]
numbers.map { 3 * $0 }

val numbers = listOf(20, 19, 7, 12)
numbers.map { 3 * it }

let numbers = [20, 19, 7, 12]
numbers.map(i => 3 * i)

var mutableArray = [1, 5, 3, 12, 2]
mutableArray.sort()

listOf(1, 5, 3, 12, 2).sorted()

let mutableArray = [1, 5, 3, 12, 2]
mutableArray.sort((a, b) => a - b)

func area(width: Int, height: Int) -> Int {
    return width * height
}
area(width: 2, height: 3)

fun area(width: Int, height: Int) = width * height
area(width = 2, height = 3)

// This is also possible with named arguments
area(2, height = 2)
area(height = 3, width = 2)

function area({width, height}) {
  return width * height
}
area({width: 2, height: 3})

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class Shape {
    var numberOfSides = 0
    fun simpleDescription() =
        "A shape with $numberOfSides sides."
}

class Shape {
  constructor() {
    this.numberOfSides = 0
  }

  simpleDescription() {
    return `A shape with ${this.numberOfSides} sides.`
  }
}

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

let shape = new Shape()
shape.numberOfSides = 7
let shapeDescription = shape.simpleDescription()

class NamedShape {
    var numberOfSides: Int = 0
    let name: String

    init(name: String) {
        self.name = name
    }

    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        self.numberOfSides = 4
    }

    func area() -> Double {
        return sideLength * sideLength
    }

    override func simpleDescription() -> String {
        return "A square with sides of length " +
	       sideLength + "."
    }
}

let test = Square(sideLength: 5.2, name: "square")
test.area()
test.simpleDescription()

open class NamedShape(val name: String) {
    var numberOfSides = 0

    open fun simpleDescription() =
        "A shape with $numberOfSides sides."
}

class Square(var sideLength: BigDecimal, name: String) :
        NamedShape(name) {
    init {
        numberOfSides = 4
    }

    fun area() = sideLength.pow(2)

    override fun simpleDescription() =
        "A square with sides of length $sideLength."
}

val test = Square(BigDecimal("5.2"), "square")
test.area()
test.simpleDescription()

class Shape {
  constructor() {
    this.numberOfSides = 0
  }

  simpleDescription() {
    return `A shape with ${this.numberOfSides} sides.`
  }
}

class NamedShape {
  constructor(name) {
    this.numberOfSides = 0
    this.name = name
  }

  simpleDescription() {
    return `A shape with ${this.numberOfSides} sides.`
  }
}

class Square extends NamedShape {
  constructor(sideLength, name) {
    super(name)
    this.sideLength = sideLength
    this.numberOfSides = 4
  }

  area() {
    return this.sideLength * this.sideLength
  }

  simpleDescription() {
    return `A square with sides of length ${this.sideLength}`
  }
}

let test = new Square(5.2, "square")
test.area()
test.simpleDescription()

var movieCount = 0
var songCount = 0

for item in library {
    if item is Movie {
        movieCount += 1
    } else if item is Song {
        songCount += 1
    }
}

var movieCount = 0
var songCount = 0

for (item in library) {
    if (item is Movie) {
        ++movieCount
    } else if (item is Song) {
        ++songCount
    }
}

let movieCount = 0
let songCount = 0

for (item in library) {
    if (item instanceof Movie) {
        movieCount += 1
    } else if (item instanceof Song) {
        songCount += 1
    }
}

let nb = 42
switch nb {
    case 0...7, 8, 9: print("single digit")
    case 10: print("double digits")
    case 11...99: print("double digits")
    case 100...999: print("triple digits")
    default: print("four or more digits")
}

val nb = 42
when (nb) {
    in 0..7, 8, 9 -> println("single digit")
    10 -> println("double digits")
    in 11..99 -> println("double digits")
    in 100..999 -> println("triple digits")
    else -> println("four or more digits")
}

// nope

for current in someObjects {
    if let movie = current as? Movie {
        print("Movie: '\(movie.name)', " +
            "dir. \(movie.director)")
    }
}

for (current in someObjects) {
    if (current is Movie) {
        println("Movie: '${current.name}', " +
	    "dir. ${current.director}")
    }
}

for (current in someObjects) {
    if (current instanceof Movie) {
        console.log(`Movie: '${current.name}', ` +
	    `dir. ${current.director}`)
    }
}

protocol Nameable {
    func name() -> String
}

func f<T: Nameable>(x: T) {
    print("Name is " + x.name())
}

interface Nameable {
    fun name(): String
}

fun f<T: Nameable>(x: T) {
    println("Name is " + x.name())
}

// If it looks like a duck,
// swims like a duck...

function f(x) {
    console.log("Name is " + x.name())
}

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
// prints "One inch is 0.0254 meters"
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
// prints "Three feet is 0.914399970739201 meters"

val Double.km: Double get() = this * 1000
val Double.m: Double get() = this
val Double.cm: Double get() = this / 100
val Double.mm: Double get() = this / 1000
val Double.ft: Double get() = this / 3.28084

val oneInch = 25.4.mm
println("One inch is $oneInch meters")
// prints "One inch is 0.0254 meters"
val threeFeet = 3.0.ft
println("Three feet is $threeFeet meters")
// prints "Three feet is 0.914399970739201 meters"

Number.prototype.km = function() { return this * 10000 }
Number.prototype.m = function() { return this }
Number.prototype.cm = function() { return this / 100 }
Number.prototype.mm = function() { return this / 1000 }
Number.prototype.ft = function() { return this / 3.28084 }

let oneInch = (25.4).mm()
console.log(`One inch is ${oneInch} meters`)
// prints "One inch is 0.0254 meters"
let threeFeet = (3.0).ft()
console.log(`Three feet is ${threeFeet} meters`)
// prints "Three feet is 0.914399970739201 meters"