scala boolean variables need to change dynamicly - scala

Question

I have this method that I need to evaluate an expression based on these Boolean values:
var Ma, Co, Ar, Le, St, Ri: Boolean = false
def Logic: Boolean =
(Ma & (!Ma | Co) & (!Ma | Ar) & (!Co | Ma) &
(!Ar | Ma) & (!Ar | Le | St | Ri))
In main() method I have:
def main(args: Array[String]) {
val ls: List[String] = List("Ma", "Co", "Ar")
//now I need to change the value of Ma, Co and Ar variables to "true"??
}
Is there a general way that may help to change the value of only these Boolean variables to true that are found in this list?

Answer 1

You can use an Enumeration, and use its ValueSet to store your true values instead of individual vars. This lets you refer to them by String name:
object MyBoolValue extends Enumeration {
type MyBoolValue = Value
val Ma, Co, Ar, Le, St, Ri = Value
}
class MyBoolValueContext {
var trueValues = MyBoolValue.ValueSet.empty
def isTrue(v: MyBoolValue) = trueValues contains v
def apply(v: MyBoolValue) = isTrue(v)
}
So then you can do:
import MyBoolValue._
val c = new MyBoolValueContext
c(Ma)
c.trueValues += Le
c.trueValues -= St
def logic: Boolean = (c(Ma) &
(!c(Ma) | c(Co)) &
(!c(Ma) | c(Ar)) &
(!c(Co) | c(Ma)) &
(!c(Ar) | c(Ma)) &
(!c(Ar) | c(Le) | c(St) | c(Ri)))
And you can use withName to handle String input:
c.trueValues ++= List("Ar", "Le", "St").map(MyBoolValue.withName)
You can get a little fancier by making the context implicit:
implicit case class ResolveMyBoolValue(self: MyBoolValue) extends AnyVal {
def get(implicit context: MyBoolValueContext): Boolean = context.isTrue(self)
}
implicit val context = new MyBoolValueContext
val result = Ar.get | !St.get
Or use an implicit conversion, though this could cause some confusion if misused:
implicit def resolveMyBoolValue(v: MyBoolValue)
(implicit context: MyBoolValueContext) = {
context.isTrue(v)
}
val result: Boolean = Le

Answer 2

Not without reflection, I think. But if you keep the name->value mapping in a map, you can do something like this:
val v = scala.collection.mutable.Map[String, Boolean]("Ma" -> false, "Co"-> false, "Ar" -> false, "Le" -> false, "St" -> false, "Ri" -> false)
//> v : scala.collection.mutable.Map[String,Boolean] = Map(Ar -> false, Le -> f
//| alse, Co -> false, Ma -> false, St -> false, Ri -> false)
def Logic:Boolean = (v("Ma") & (!v("Ma") | v("Co")) & (!v("Ma") | v("Ar")) & (!v("Co") | v("Ma")) &
(!v("Ar") | v("Ma")) & (!v("Ar") | v("Le") | v("St") | v("Ri")))
//> Logic: => Boolean
val ls: List[String] = List("Ma", "Co", "Ar") //> ls : List[String] = List(Ma, Co, Ar)
v("Ma") //> res0: Boolean = false
ls.foreach(v(_) = true)
v("Ma") //> res1: Boolean = true
Logic //> res2: Boolean = false

Answer 3

One of the ways to do it:
def Logic(params:List[String]) = {
val p = params.map(par => (par, true)).toMap.withDefaultValue(false)
(
p("Ma") & (
!p("Ma") | p("Co")
) & (
!p("Ma") | p("Ar")
) & (
!p("Co") | p("Ma")
) & (
!p("Ar") | p("Ma")
) & (
!p("Ar") | p("Le") | p("St") | p("Ri")
)
)
}
scala> Logic(List("Ma","Co","Ar"))
res0: Boolean = false
scala> Logic(List("Ma","Co","Ar","Le"))
res1: Boolean = true