val findAlice = persons.find{ it.name == "Alice" }
    val findBob = persons.find{it.name == "Bob"}

persons.Select( x => x.name == "Alice")

    val findBob = persons.find{ x ->  x.name == "Bob"}

    if(value is String)
    	println(value.toUpperCase())

fun main(args: Array<String>){
    println("Hello, world!")
}

fun main(args: Array<String>){
    println(max(1, 2))
}

fun max(a: Int, b: Int): Int{
    return if (a > b) a else b
}

if ( b = true) { /* 何かしらの処理 */ }

fun main(args: Array<String>){
    val name = if (args.size > 0 ) args[0] else "Kotlin"
    print("Hello, $name")
}

fun main(args: Array<String>){
    val name = if (args.size > 0 ) args[0] else "Kotlin"
    print("Hello, ${args[0]}")
}

fun main(args: Array<String>){
    val name = if (args.size > 0 ) args[0] else "Kotlin"
    print("Hello, $args[0]")
}

>>> Hello, [Ljava.lang.String;@e9e54c2[0]

public class Person {
    private final String name;

    public Person(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }
}

class Person(val name: String)

class Rectangle(val height: Int, val width: Int) {
    val isSqure: Boolean
        get() {
            return height == width
        }
}

// enumの簡単な宣言
enum class Color {
    RED, ORAGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

// プロパティと一緒に宣言
enum class Colors (
    val r: Int, val g: Int, val b: Int
){
    RED(255, 0, 0),
    ORANGE(255, 165, 0),
    YELLOW(255, 255, 0),
    GREEN(0, 255, 0),
    BLUE(0, 0, 255),
    INDIGO(75, 0, 130),
    VIOLET(238, 130, 238);

    fun rgb() = (r * 256 + g) * 256 + b
}

>>> :load 2chapter/Color.kt
>>> println(Colors.BLUE)
BLUE
>>> println(Colors.BLUE.r)
0
>>> println(Colors.BLUE.g)
0
>>> println(Colors.BLUE.b)
255
>>> 

fun getMnemonic(color: Colors) =
    when (color) {
        Colors.RED -> "Richard"
        Colors.ORANGE -> "Of"
        Colors.YELLOW -> "York"
        Colors.GREEN -> "Gave"
        Colors.BLUE -> "Battle"
        Colors.INDIGO -> "In"
        Colors.VIOLET -> "Vain"
    }

fun getWarmth(color: Colors) =
    when(color){
        Colors.ORANGE, Colors.YELLOW -> "warm"
        Colors.GREEN -> "neutral"
        Colors.BLUE, Colors.INDIGO, Colors.VIOLET -> "cold"
        else -> "else"
    }

>>> println(getWarmth(Colors.BLUE))
cold
>>> println(getWarmth(Colors.RED))
else

fun mix(c1: Colors , c2: Colors) =
    when (setOf(c1, c2)) {
        setOf(Colors.RED, Colors.YELLOW) -> Colors.ORANGE
        setOf(Colors.YELLOW, Colors.BLUE) -> Colors.GREEN
        setOf(Colors.BLUE, Colors.VIOLET) -> Colors.INDIGO
        else -> throw Exception("Dirty color")
    

fun mix(c1: Colors , c2: Colors) =
    when (setOf(c1, c2)) {
        setOf(Colors.RED, Colors.YELLOW) -> Colors.ORANGE
        else -> throw Exception("Dirty color")
        setOf(Colors.YELLOW, Colors.BLUE) -> Colors.GREEN
        setOf(Colors.BLUE, Colors.VIOLET) -> Colors.INDIGO
    }

error: 'else' entry must be the last one in a when-expression
        else -> throw Exception("Dirty color")
        ^

interface Expr

class Num (val value: Int) : Expr

class Sum (val left: Expr, val right: Expr) : Expr

fun eval(e: Expr): Int {
    if ( e is Num){
        return e.value
    }
    if (e is Sum){
        return eval(e.right) + eval(e.left)
    }
    throw IllegalArgumentException("Unknown expression")

}

fun evalWithLogging(e: Expr): Int =
    when (e) {
        is Num -> {
            println("num: ${e.value}")
            e.value // ブロック最後が、関数の戻り値となる。returnが要らない。
        }
        is Sum -> {
            val left = evalWithLogging(e.left)
            val right = evalWithLogging(e.right)
            println("sum: $left + $right")
            left + right
        }
        else -> throw IllegalArgumentException("Unknwn expression")
    }

fun test(): Int {
    1 // これはエラー
}

>>> for(i in 1..10) { println(i)}
1
2
3
4
5
6
7
8
9
10

fun fizzBuzz(i: Int) = when{
    i % 15 == 0 -> "FizzBuzz"
    i % 3 == 0 -> "Fizz"
    i % 5 == 0 -> "Buzz"
    else -> "$i"
}

fun main() {
    for (i in 1..10){
        print(fizzBuzz(i) + " ")
    }

    for (i in 100 downTo 1 step 2){
        print(fizzBuzz(i) + " ")
    }
}

public infix fun Int.downTo(to: Int): IntProgression {
    return IntProgression.fromClosedRange(this, to, -1)
}

public infix fun IntProgression.step(step: Int): IntProgression {
    checkStepIsPositive(step > 0, step)
    return IntProgression.fromClosedRange(first, last, if (this.step > 0) step else -step)
}

    // こちらと書き方同じ。
//    for (i in 100 downTo 1 step 2 ){
//        print(fizzBuzz(i) + " ")
//    }
    for (i in 100.downTo(1).step(2) ){
        print(fizzBuzz(i) + " ")
    }

fun readNumber(reader: BufferedReader): Int? {
    try {
        val line = reader.readLine()
        return Integer.parseInt(line)
    }
    // Javaでは非検査例外ではあるけど、不正な入力データは一般的に起こりうるのでキャッチしたほうがいいかもしれない？
    catch (e: NumberFormatException){
        return null
    }
    finally {
        // closeするときには、IOExceptionをスローする可能性があるが、ストリームを閉じる時に意味のあるアクションを取ることができない。
        // 大体が、もう一度試みるか、握りつぶすしかない、というお話なのかな？
        // そうなると意味のないボイラーテンプレートとなってしまい、コードの可読性を下げてしまうことに繋がる、ということみたいだ
        reader.close()
    }
}

>>> println(set.javaClass)
class java.util.HashSet

//  ↓レシーバ型　　　　　　↓レシーバオブジェクト
fun String.lastChar(): Char = this.get(this.length - 1)

println("Kotlin".lastChar())
n

// メンバ関数のオーバーライド
// val view: View = Button()
// view.click()すると、 Button clickedが表示される
open class View {
    open fun click() = println("View clicked")
}

class Button: View() {
    override fun click() = println("Button clicked")
}

// メンバーバーライド
// val view: View = Button()
// view.click()すると、 I'm a view! が表示される
fun View.showOff() = println("I'm a view! ")
fun Button.showOff() = println("I'm a button!")

>>> val sum = { x: Int, y:Int -> x + y }
>>> sum(1, 2)
res55: kotlin.Int = 3
>>> sum
res56: (kotlin.Int, kotlin.Int) -> kotlin.Int = (kotlin.Int, kotlin.Int) -> kotlin.Int

interface Clickable {
    fun click()
    fun showOff() = println("I'm clickable!")
}

interface Focusable {
    fun setFocus(b: Boolean) = println("I ${if (b) "got" else "lost"} focus.")
    fun showOff() = println("I'm focusable!")
}

class Button : Clickable, Focusable {
    override fun click() =
        println("I was clicked")
    override  fun showOff() {
        super<Clickable>.showOff()
        super<Focusable>.showOff()
    }
}

fun main(args: Array<String>)
{
    val button = Button()
    button.showOff()
    button.setFocus(true)
    button.click()
}

// openなので、他のクラスはこれを継承することができる
// 基底クラスやインターフェースのメンバをオーバーライドした場合は、デフォルトでopenである

open class RichButton: Clickable {
    fun disable() {} // final扱い
    open fun animate() {} // openなのでサブクラスでオーバーライドできる
    override fun click() {} // openな関数をオーバーライドしているので、openとなる
    override final fun showOff() {} // 明示的にfinalを付けられる
}

class VeryRichButton: RichButton() {
    override fun showOff() {} // 'showOff' in 'RichButton' is final and cannot be overridden
}

import java.io.Serializable

interface State: Serializable

interface View {
    fun getCurrentState(): State
    fun restoreState(state: State) {}
}

class Button: View {
    override fun getCurrentState(): State = ButtonState()
    override fun restoreState(state: State) {}

    class ButtonState: State {}
}

class ABC {
    inner class Inner {
        fun getOuterRefernce(): ABC = this@ABC
    }
}

sealed class Expr {
    class Num(val value: Int): Expr()
    class Sum(val left: Expr, val right: Expr): Expr()
    class hoge(): Expr() // これを追加すると、下のwhen式で怒られる
}

fun eval(e: Expr): Int =
    when (e) { // 'when' expression must be exhaustive, add necessary 'is hoge' branch or 'else' branch instead
        is Expr.Num -> e.value
        is Expr.Sum -> eval(e.right) + eval(e.left)
    }

open class Button2()

class RadioButton: Button2 // This type has a constructor, and thus must be initialized here

open class Button2()

class RadioButton: Button2()

class PrivateConstructor private constructor(val nickname: String) {

    companion object {
        fun create(nickname: String) = PrivateConstructor(nickname)
    }
}

>>> val con = PrivateConstructor("abc")
error: cannot access '<init>': it is private in 'PrivateConstructor'
val con = PrivateConstructor("abc")
          ^

>>> val con = PrivateConstructor.create("abc")
>>> con.nickname
res8: kotlin.String = abc
>>>