kmizu

sealed trait Sequence[+T]
case class Cons[+T](head: T, tail: Sequence[T]) extends Sequence[T]
case object Empty extends Sequence[Nothing]

object Main {
  def last2[T](list: Sequence[T]): Sequence[T] = list match {
    case result@Cons(_, Cons(_, Empty)) => result
    case Empty =>
      sys.error("list should not be empty")
    case Cons(_, Empty) =>

kmizu

table {
  row {
    cell("A")
    cell("B")
    cell("C")
  }
  row {
    cell("1")
    cell("2")
  }

kmizu

fn test() -> Box<MFunBox<i32, Box<Vec<i32>>>> {
    let mut v = Box::new(vec![1, 2, 3]);
    return Box::new(move |x: i32|{ v.push(x); v});
}

trait MFunBox<A, B> {
    fn mcall(self: Box<Self>, arg: A) -> B;
}

impl<A, B, T:FnOnce(A) -> B> MFunBox<A, B> for T {

kmizu

case class Text(body: String)

object Text {
  def pack(body: String): Text = Text(body)
}

trait Show[A] {
  def show(a: A): String
}

kmizu

object G {
  def main(args: Array[String]): Unit = {
    println(
      List(1, 2, 3)
        .map{x => x * 2}
        .filter{x => x > 2}
    )
  }
}

kmizu

def add(x: Int, y: Int): Int = {
  x + y
}

kmizu

fun main(args: Array<String>) {
  val message: String? = null
  println(message?.length)
}

kmizu

‘try’ (‘{’ Block ‘}’ | Expr) [‘catch’ ‘{’ CaseClauses ‘}’] [‘finally’ Expr]

kmizu

def when[A](cond: Boolean)(th: => A)(el: => A): A = if(cond) th else el

var i = 1
when(i < 2) {
  println("i < 2")
} {
  println("i >= 2")
}
// i < 2

kmizu

class Foo {
    var myList: List<String>? = null
    fun hoge(list: List<String>) {
        myList = list
    }
}