ricky

class Snoc[T](list: List[T]) { def >>[U >: T](x: U): List[U] = x :: list }
implicit def list2Snoc[T](xs: List[T]): Snoc[T] = new Snoc(xs)
object >> { def unapply[T](cons: scala.::[T]): Option[(List[T], T)] = Some((cons.tail, cons.head)) }

sealed trait Term
case object True extends Term
case object False extends Term
case object O extends Term
case class Succ(t: Term) extends Term

def parseTerm(s: String, stack: List[Term]): List[Term] = s match {
 case "true" => stack >> True
 case "false" => stack >> False
 case "O" => stack >> O
 case "succ" => stack match { case rest >> t => rest >> Succ(t)
                              case _ => throw null }
 case "pred" => stack match { case rest >> O => rest >> O
                              case rest >> Succ(t) => rest >> t
                              case _ => throw null }
 case "if" => stack match { case rest >> then >> otherwise >> True => rest >> then
                            case rest >> then >> otherwise >> False => rest >> otherwise
                            case _ => throw null }
 case "isZero" => stack match { case rest >> O => rest >> True
                                case rest >> _ => rest >> False
                                case _ => throw null }
}

println
print("> ")
import java.io.{BufferedReader, InputStreamReader}
val in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"))
val line = in.readLine
println(line.split(" ").foldLeft(Nil : List[Term])((stack, token) => parseTerm(token, stack)))