reactive-programming-week-2-assignment.scala

def tweetRemainingCharsCount(tweetText: Signal[String]): Signal[Int] = {
  Signal(MaxTweetLength - tweetLength(tweetText()))
}

def colorForRemainingCharsCount(remainingCharsCount: Signal[Int]): Signal[String] = {
 Signal({
   remainingCharsCount() match {
     case x if x >= 15 => "green"
     case x if x >= 0 => "orange"
     case _ => "red"
   }
 })
}

def computeDelta(a: Signal[Double], b: Signal[Double],
      c: Signal[Double]): Signal[Double] = {
  Signal(b() * b() - 4 * a() * c())
}

def computeSolutions(a: Signal[Double], b: Signal[Double], 
    	c: Signal[Double], delta: Signal[Double]): Signal[Set[Double]] = {
  Signal({
    delta() match {
      case 0 => Set((-1 * b()) / (2 * a()))
      case d if (d > 0) => Set(
        (-1 * b() - Math.pow(delta(), 0.5)) / (2 * a()),
        (-1 * b() + Math.pow(delta(), 0.5)) / (2 * a())
      )
      case _ => {
        Set()
      }
    }
  })
}

def computeValues(namedExpressions: Map[String, Signal[Expr]]): Map[String, Signal[Double]] = {
  namedExpressions map {
    case (name, expression) => {
      expression.apply() match {
        case Ref(name) => (name, Signal(eval(expression(), namedExpressions.filter(_._1 != name))))
        case _ => (name, Signal(eval(expression(), namedExpressions)))
      }
    }
  }
}

def eval(expr: Expr, references: Map[String, Signal[Expr]]): Double = {
  expr match {
    case Literal(v) => v
    case Plus(a, b) => eval(a, references) + eval(b, references)
    case Minus(a, b) => eval(a, references) - eval(b, references)
    case Times(a, b) => eval(a, references) * eval(b, references)
    case Divide(a, b) => eval(a, references) / eval(b, references)
    case Ref(name) => eval(getReferenceExpr(name, references), references.filter(_._1 != name))
  }
}