scala - tutorial - tabla de verdad funciones booleanas

¿Cómo usar/referirse a la negación de una función booleana en Scala?

Question

Estoy tratando de usar la negación de una función booleana en Scala, como por ejemplo:

def someFunction(x: Set, p: Int => Boolean): Boolean = 
    someOtherFunction(x, !p)

Pero me sale el error:

 value unary_! is not a member of Int => Boolean

¿Cómo puedo referirme a la negación de p?

Answer 1

La negación de p es una función que aplica p a su argumento y niega el resultado.

x => !p(x)

Si desea poder escribir !p o p && q , puede usar esta biblioteca , que proxenetas funciona y devuelve un bool con varios operadores lógicos.

Answer 2

La negación más corta de p :! P (_)

Cuando aplica el predicado p como argumento a otra función:

• p o p (_) son abreviaturas de la expresión lambda: (x) => p (x)
• ! p (_) es una abreviatura de la expresión lambda: (x) =>! p (x) y con only! p el compilador se pierde.

Por ejemplo, usando un conjunto de enteros (pruébelo en una hoja de trabajo de Scala):

  def someOtherFunction (x: Set[Int], p: Int => Boolean):Boolean = x.forall(p)
  def someFunction(x: Set[Int], p: Int => Boolean): Boolean =
    someOtherFunction(x, !p(_))

  val x = Set(1,2,3)
  var p: Int => Boolean = (_ > 0)
  //_ > 0 is an abbreviaton of (x) => x > 0

  someFunction(x, p)        //false
  someOtherFunction(x, p)   //true

  p = _ > 1
  someFunction(x, p)        //false
  someOtherFunction(x, p)   //false

  p = _ > 3
  someFunction(x, p)        //true
  someOtherFunction(x, p)   //false
  println

Answer 3

Otra forma de resolverlo sin el uso de una función anónima es definir una función concreta para esta tarea.

def even(x:Int):Boolean = x%2==0
def not(f: Int => Boolean): Int => Boolean = !f(_)
def odd = not(even)
odd(1) // true
odd(2) // false

¡También puedes definir! tú mismo

def even: Int => Boolean = _%2==0
implicit def bangy(f: Int => Boolean) = new { def unary_! : Int => Boolean = !f(_) }
def odd = !even
odd(1) // true
odd(2) // false

pero esto solo parece funcionar para funciones de tipo Int => Boolean, y no (Int) => Boolean. La solución no (par) funciona con ambos.