Способ уменьшить избыточность в следующих определениях булевых функций?

Question

Я просто ищу лучшие способы ведения дел в Scala, поэтому задаю вопросы новичкам. Например:

Я хотел быть в состоянии сделать что-то вроде следующего:

Учитывая a, b, c, которые являются "логическими":

if (((a nand b) nand c) != (a nand (b nand c))) printf("NAND is not associative")

Где я буду переключаться между возможными логическими значениями a, b, c. Я сделал это:

for (i <- 0 to 7) {
  val (a,b,c) = (new MyBoolean((i & 4) >> 2 == 1),
                 new MyBoolean((i & 2) >> 1 == 1),
                 new MyBoolean((i & 1) == 1))
  printf("%d (%s,%s,%s)\n",i,a,b,c)
  if (((a nand b) nand c) != (a nand (b nand c))) printf("NAND\n")
}

Я думаю, я мог бы несколько упростить это до:

val (a,b,c) = (new MyBoolean(i & 4 != 0),
               new MyBoolean(i & 2 != 0),
               new MyBoolean(i & 1 != 0))

Где мой класс MyBoolean выглядит так:

class MyBoolean(val p: Boolean) {
  def and(q: MyBoolean): MyBoolean = new MyBoolean(p && q.p)
  override def toString: String = p.toString
  override def equals (o : Any): Boolean = o match {
      case m : MyBoolean => p == m.p
      case _ => false
  }
  def and(q: Boolean): MyBoolean = new MyBoolean(p && q)
  def or(q: Boolean): MyBoolean = new MyBoolean(p || q)
  def or(q: MyBoolean): MyBoolean = or(q.p)
  def negate: MyBoolean = new MyBoolean(!p)
  def nand(q : Boolean): MyBoolean = new MyBoolean(!(p && q))
  def nand(q : MyBoolean): MyBoolean = nand(q.p)
  def nor(q : Boolean): MyBoolean = new MyBoolean(!(p || q))
  def nor(q : MyBoolean): MyBoolean = nor(q.p)
  def xor(q : Boolean): MyBoolean = new MyBoolean((p || q) && !(p && q))
  def xor(q : MyBoolean): MyBoolean = xor(q.p)
  def implies(q : Boolean): MyBoolean = new MyBoolean(!(p && !q))
  def implies(q : MyBoolean): MyBoolean = implies(q.p)
  def equiv(q : Boolean): MyBoolean = new MyBoolean(p == q)
  def equiv(q : MyBoolean): MyBoolean = equiv(q.p)
}

Это разумно, или есть намного лучший способ сделать это? :)

Мне не повезло, пытаясь что-то вроде:

def nand(p : Boolean, q : Boolean): Boolean = !(p && q)

Я не мог оттуда поехать:

(a nand (b nand c))

Как я и надеялся (против надежды). :) Я бы на самом деле не хотел вводить новый тип, было бы неплохо просто иметь nand, и т.д ... работать с Boolean.

Я думаю, что мой main также взывает к тому, чтобы сделать вещи менее избыточными, я использую разные функции в нескольких строках ... но единственное, что меняется, - это имя функции.

def main(args: Array[String]): Unit = {
 for (i <- 0 to 7) {
  val (a,b,c) = (new MyBoolean((i & 4) != 0),
                 new MyBoolean((i & 2) != 0),
                 new MyBoolean((i & 1) != 0))
  printf("%d (%s,%s,%s)\n",i,a,b,c)
  if (((a nand b) nand c) != (a nand (b nand c))) printf("NAND\n")
  if (((a implies b) implies c) != (a implies (b implies c))) printf("IMPLIES\n")
  if (((a nor b) nor c) != (a nor (b nor c))) printf("NOR\n")
  if (((a xor b) xor c) != (a xor (b xor c))) printf("XOR\n")
  if (((a equiv b) equiv c) != (a equiv (b equiv c))) printf("EQUIV\n")
 }
}

-Jay

Answer 1

Вы должны использовать для этого неявные преобразования, например:

class MyBoolean {/*...*/} 
implicit def decorateBoolean(x:Boolean) = new MyBoolean(x)

for (i <- 0 to 7) {
  val (a,b,c) = ((i & 4) != 0,
                 (i & 2) != 0,
                 (i & 1) != 0)
  printf("%d (%s,%s,%s)\n",i,a,b,c)
  if (((a nand b) nand c) != (a nand (b nand c))) printf("NAND\n")
}

Вы удалили синтаксический багаж конструкции объекта из вашего исходного кода.Вы просто должны надеяться, что JVM соответствующим образом оптимизирует конструкцию объекта, когда она JITs ваш код.

Answer 2

Как Кен Блум, я бы предложил использовать неявные преобразования, чтобы сохранить всю эту типизацию.Было бы удобно иметь преобразование в другом направлении (MyBoolean -> Boolean).

Кроме того, очень и очень расточительно создавать новый экземпляр, когда все, что у вас есть, - это два разных значения.Если вы используете два объекта для этих экземпляров, вам больше не нужны ссылки на исходный логический тип.

Вот как я бы это написал:

sealed trait MyBoolean {
  import MyBoolean._

  def and(that: MyBoolean): MyBoolean = (this, that) match {
    case (TRUE,TRUE) => TRUE
    case _ => FALSE
  }

  def or(that: MyBoolean): MyBoolean = (this, that) match {
    case (FALSE, FALSE) => FALSE
    case _ => TRUE
  }

  def negate: MyBoolean = this != TRUE
  def nand(that: MyBoolean): MyBoolean = (this and that).negate
  def nor(that: MyBoolean): MyBoolean = (this or that).negate
  def xor(that: MyBoolean): MyBoolean = this != that
  def implies(that: MyBoolean): MyBoolean = (this and that.negate).negate
  def equiv(that: MyBoolean): MyBoolean = this == that
}

case object TRUE extends MyBoolean
case object FALSE extends MyBoolean

object MyBoolean {
  implicit def bool2MyBool(p:Boolean):MyBoolean = MyBoolean(p)
  implicit def myBool2bool(m:MyBoolean):Boolean = m == TRUE
  def apply(p:Boolean):MyBoolean = if (p) TRUE else FALSE
}

Обратите внимание, что вам не нужны равенства (потому что мы можем теперь полагаться на идентичность объекта) и toString (потому что это уже реализованоcase-объекты и классы).

[Edit] Реализация с учетом замечаний Кена:

sealed trait MyBoolean {
  def and(that: MyBoolean): MyBoolean
  def or(that: MyBoolean): MyBoolean
  def negate: MyBoolean
  def equiv(that: MyBoolean): MyBoolean = if (this == that) TRUE else FALSE
  def nand(that: MyBoolean): MyBoolean = (this and that).negate
  def nor(that: MyBoolean): MyBoolean = (this or that).negate
  def xor(that: MyBoolean): MyBoolean = (this equiv that).negate
  def implies(that: MyBoolean): MyBoolean = (this and that.negate).negate
}

case object TRUE extends MyBoolean {
  def negate = FALSE
  def and(that:MyBoolean) = that
  def or(that:MyBoolean) = this
}
case object FALSE extends MyBoolean {
  def negate = TRUE
  def and(that:MyBoolean) = this
  def or(that:MyBoolean) = that
}

object MyBoolean {
  implicit def bool2MyBool(p:Boolean):MyBoolean = MyBoolean(p)
  implicit def myBool2bool(m:MyBoolean):Boolean = m == TRUE
  def apply(p:Boolean):MyBoolean = if (p) TRUE else FALSE
}

Answer 3

Это улучшение ответа Ландеи, основанное на том, как Руби делает это:

sealed trait MyBoolean {
  val toBoolean:Boolean
  def and(that: MyBoolean): MyBoolean
  def or(that: MyBoolean): MyBoolean
  def negate: MyBoolean
  def nand(that: MyBoolean): MyBoolean
  def nor(that: MyBoolean): MyBoolean
  def xor(that: MyBoolean): MyBoolean
  def implies(that: MyBoolean): MyBoolean
  def equiv(that: MyBoolean): MyBoolean
}

case object TRUE extends MyBoolean{
   override val toBoolean = true
   override def and(that:MyBoolean) = that
   override def or(that:MyBoolean) = TRUE
   override def negate: MyBoolean = FALSE
   override def nand(that:MyBoolean) = that.negate
   override def nor(that:MyBoolean) = FALSE
   override def xor(that:MyBoolean) = that.negate
   override def implies(that:MyBoolean) = that
   override def equiv(that:MyBoolean) = that
}

case object FALSE extends MyBoolean{
   override val toBoolean = false
   override def and(that:MyBoolean) = FALSE
   override def or(that:MyBoolean) = that
   override def negate: MyBoolean = TRUE
   override def nand(that:MyBoolean) = TRUE
   override def nor(that:MyBoolean) = that.negate
   override def xor(that:MyBoolean) = that
   override def implies(that:MyBoolean) = TRUE
   override def equiv(that:MyBoolean) = that.negate
}

object MyBoolean {
  implicit def bool2MyBool(p:Boolean):MyBoolean = MyBoolean(p)
  implicit def myBool2bool(m:MyBoolean):Boolean = m.toBoolean
  def apply(p:Boolean):MyBoolean = if (p) TRUE else FALSE
}

Answer 4

Мне нужно узнать, как работает преобразование типов данных, и узнать подробности об особенностях. Что я делаю в данный момент (с кодом ОЧЕНЬ похожим на то, что я нашел http://scalasolutions.wordpress.com/2010/07/22/p46-truth-tables-for-logical-expressions/):

object Logic {
  type T = Boolean

  def and(p : T, q : T) = p && q
  def or(p : T, q : T) = p || q
  def negate(p : T) = !p
  def nand(p : T, q : T) = !(p && q)
  def nor(p : T, q : T) = !(p || q)
  def xor(p : T, q : T) = p != q
  def implies(p : T, q : T) = !(p && !q)
  def equiv(p : T, q : T) = p == q
}

def main(args: Array[String]): Unit = {
  import Logic._
  type T = ((Boolean, Boolean) => Boolean, String)
  val checklist =
    List((nand, "NAND\n") : T, (implies, "IMPLIES\n") : T, (nor, "NOR\n") : T,
   (xor, "XOR\n") : T, (equiv, "EQUIV\n") : T)
  // Check associativity of boolean operators does a+(b+c) = (a+b)+c ?
  for (i <- 0 to 7) {
    val (a,b,c) = ((i & 4) != 0, (i & 2) != 0, (i & 1) != 0)
    printf("%d (%s,%s,%s)\n",i,a,b,c)
    checklist.foreach(t => if (t._1(t._1(a,b),c) != t._1(a,t._1(b,c))) printf(t._2))
  }
}