Scala - operowanie na pierwszych n elementach listy

  def main(args: Array[String]): Unit = {
        println(eval(List("1","2","*","3","+")))
}
  def eval(t: List[String]): Int = {
    def eval(t: List[String], valueStack: List[Int]): Int = t match {
      case Nil => valueStack.head
      case "+" :: _ => eval(t.tail, (valueStack.head + valueStack.drop(1).head) :: valueStack.drop(2));
      case "-" :: _ => eval(t.tail, (valueStack.head - valueStack.drop(1).head) :: valueStack.drop(2));
      case "*" :: _ => eval(t.tail, (valueStack.head * valueStack.drop(1).head) :: valueStack.drop(2));
      case "*" :: _ => eval(t.tail, (valueStack.head / valueStack.drop(1).head) :: valueStack.drop(2));
      case n :: _ => eval(t.tail, n.toInt :: valueStack)
    }
    eval(t, Nil)
  }

  def eval(t: List[String]): Int = {
    def eval(t: List[String], valueStack: List[Int]): Int = t match {
      case Nil => valueStack.head
      case "+" :: _ => eval(t.tail, operateOnFirstDwo[Int](valueStack, _ + _))
      case "-" :: _ => eval(t.tail, operateOnFirstDwo[Int](valueStack, _ - _))
      case "*" :: _ => eval(t.tail, operateOnFirstDwo[Int](valueStack, _ * _))
      case "/" :: _ => eval(t.tail, operateOnFirstDwo[Int](valueStack, _ / _))
      case n :: _ => eval(t.tail, n.toInt :: valueStack)
    }
    eval(t, Nil)
  }

  def operateOnFirstDwo[T](list:List[T], f: (T,T)=>T):List[T] = {
    f(list.head, list.drop(1).head) :: list.drop(2)
  }

case "+" :: _ => eval(t.tail, operateOnFirstDwo[Int](valueStack, _ + _))

 case "+" :: tail => eval(tail, operateOnFirstDwo[Int](valueStack, _ + _))

'7 8 + 3 2 + /'
'1 2 + 3 4 + *'
"1 2 + 3 * 4 5 - 6 7 + * -"

  def operateOnFirstDwo[T](list:List[T], f: (T,T)=>T):List[T] = {
    f(list.drop(1).head,list.head) :: list.drop(2)
  }

import scala.annotation.tailrec
import scala.util.Try

object Evaluator {
  def main(args: Array[String]): Unit = {
    println(eval(List("1", "2", "*", "3", "+")))
  }

  private val ops = Map[String, (Int, Int) => Int](
    "+" -> (_ + _),
    "-" -> (_ - _),
    "*" -> (_ * _),
    "/" -> (_ / _),
  )

  def eval(tokens: List[String]): Int = {
    @tailrec
    def go(tokens: List[String], values: List[Int]): Int = {
      (tokens, values) match {
        case (Nil, List(result)) =>
          result
        case (op :: tokensTail, arg1 :: arg2 :: valuesTail) if ops.contains(op) =>
          val result = ops(op)(arg1, arg2)
          go(tokensTail, result :: valuesTail)
        case (n :: tokensTail, _) if Try(n.toInt).isSuccess =>
          go(tokensTail, n.toInt :: values)
        case _ =>
          sys.error(s"invalid state. tokens = $tokens, values = $values")
      }
    }
    go(tokens, Nil)
  }
}