F# examples translated to Scala

gistfile1.scala

val r = (42, "Hello")
val (num, str) = r

case class Product(name: String, price: Float)
val p = Product("Test", 128.8f)
val p2 = p.copy(name = "Another")
val p3 = Product("Test", 128.8f)

// structural comparision of case classes
p == p3

sealed trait Expr
case class Constant(n: Int) extends Expr
case class Variable(name: String) extends Expr
case class Binary(op: String, left: Expr, right: Expr) extends Expr

def getVariableValue(name: String): Int = name match {
  case "x" => 10
  case _   => throw new IllegalArgumentException("no such variable")
}

// return type is required for recursive methods
def eval(expr: Expr): Int = expr match {
  case Constant(n) => n
  case Variable(name) => getVariableValue(name)
  case Binary(op, left, right) => {
    val leftVal  = eval(left)
    val rightVal = eval(right)
    // because op is a string, the compiler will complain about non-exhaustive pattern matching
    op match {
      case "+" => leftVal + rightVal
      case "-" => leftVal - rightVal
      case "*" => leftVal * rightVal
      case "/" => leftVal / rightVal
    }
  }
}

val expr1 = Binary("+", Constant(10), Variable("x"))
val expr2 = Binary("*", Variable("x"), Constant(2))
val expr3 = Binary("-", expr1, expr2)
eval(expr3)

val d = Seq(1, 2, 3, 4, 5)
d.map { x => x * x }
 .filter { x => x % 2 == 0 }
 .sum


def add(a: Int)(b: Int) = a + b
def add10 = add(10)_

// alternate syntax
def add(a: Int, b: Int) = a + b
def add10 = add(10, _: Int)

sealed trait Variant
case class Num(num: Int) extends Variant
case class Str(str: String) extends Variant

val vn = Num(42)
val vs = Str("Are we having fun yet???")

def printIt(v: Variant) = v match {
  case Num(n) => s"Number: $n"
  case Str(s) => s"String: $s"
}

printIt(vn)
printIt(vs)