Javascript in Scala

javascript-in-scala.scala

// Function "add" implemented in javascript
 
function add(x, y) {
  return x + y;
}
 
// Function "add" implemented in Scala as javascript is actually implementing it behind the scenes
 
sealed abstract class DynamicType
 
case class Int(value: BitSet) extends DynamicType
object Int {
  def add(x: Int, y: Int) = ???
  def toString(x: Int) = ???
}
 
case class String(value: BitSet) extends DynamicType
object String {
  def add(x: String, y: String) = ???
}
 
case class Function extends DynamicType {
  var apply: () => this.type
  var prototype = Map[String, DynamicType]()
}
 
case class Object extends Function

case class Array(value: ???) extends DynamicType {
  def toString = Array.join(value, ",")	
}
object Array {
  def join(ar: Array) = ???
}
 
// --- add ---
 
def add(x: DynamicType, y: DynamicType) x match {
  case x: Int => y match {
    case y: Int => Int.add(x, y)
    case y: String => String.add(x.toString(), y)   //  5 + "6"   >> "56"
    case y: Object => String.add(x.toString(), y.toString())  //  6 + {}  >>  "6[object Object]"
    case _ => throw new Exception
  }
  case x: String => y match {
    case y: String => String.add(x, y)
    case y => String.add(x, y.toString())  //  "a" + function f(){}  >> "afunction f(){}"
  }
  case _: Function => y match {
    case y: Int => y.toString()    // function f(){} + 6  >>  "6"
    case y: Array if y.length == 0 => 0  //  function f(){} + [0]  >>  0
    case y: Array if y.length == 1 => y[0]  //  function f(){} + [6]  >>  6
    case _ => throw new NotANumberException  // function f(){} + {}  >>  NaN
  }
  case a: Array => String.add(a.toString , y.toString)   // [5,6] + [4,5]  >>  "5,64,5"
}