blog memo

1.kt

fun sayHello(target : String) {
  println("Hello, $target!")
}

val target : Any = "world"

if(target is String) {
  sayHello(target) // Hello, world!
}

1.scala

def sayHello(target : String) = println(s"Hello, $target!")

val target : Any = "world"

target match {
  case x:String => sayHello(x)
  case _ =>
}

2.kt

fun isUpperCase(str : String) : Boolean {
  fun String.all(f : (Char) -> Boolean) : Boolean {
    for(val c in this) {
      if(!f(c)) {
        return false
      }
    }

    return true
  }


  return str.all {
    Character.isUpperCase(it)
  }
}

2.scala

def isUpperCase(str : String) : Boolean = {

  implicit class MyRichString(val self : String) {
    def all(f : Char => Boolean) : Boolean = self.forall(f)
  }

  str.all(Character.isUpperCase)
}

3.kt

fun run(f : () -> Unit) = f()

// リテラルじゃないから引数として渡せないらしい
//fun sayHello() {
//  println("Hello")
//}

val sayHello = {
  println("Hello")
}

run(sayHello)

3.scala

def run(f: () => Unit ) = f()

val runLiteral = (f:() => Unit) => f()

def sayHelloFunc() = println("Func!!")

val sayHelloLiteral = () => println("Literal!!")

run( sayHelloFunc )

run( sayHelloLiteral )

runLiteral( sayHelloFunc )

runLiteral( sayHelloLiteral )

4.kt

when(pair) {
  is #(0, 0)           -> "(0, 0)"
  is #(0, Int)         -> "(0, Int)"
  is #(Int, 0)         -> "(Int, 0)"
  is #(Int, Int)       -> "(Int, Int)"
  is #(String, String) -> "(String, String)"
  else                 -> "unknown"
}

4.scala

val pair:(Any, Any) = ...

pair match {
  case (0, 0)               => "(0, 0)"
  case (0, _:Int)           => "(0, Int)"
  case (_:Int, 0)           => "(Int, 0)"
  case (_:Int, _:Int)       => "(Int, Int)"
  case (_:String, _:String) => "(String, String)"
  case _                    => "unknown"
}

5.kt

val pair : #(String, Int) = #("taro", 23) // ← 先日25歳になっていたような…ｗ

if(pair is #(val a, val b)) {
  println("$a ($b)") // taro (23)
}

5.scala

val pair = ("taro", 23)

// スマートキャストとおんなじような事やるならパターンマッチも使えばいいかな
val (a, b) = pair