如何减少以下布尔函数定义中的冗余？

Question

我只是在寻找更好的Scala做事方式,所以问新手问题.例如:

我希望能够做以下事情:

给定a,b,c为"boolean":

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.

我认为我的主要人员也呼吁减少冗余,我在几行上使用不同的功能......但唯一改变的是功能名称.

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在JIT代码时适当地优化对象构造.