Escala | Condiciones previas (afirmar, asumir, exigir, garantizar)

Las condiciones previas se refieren a algunas condiciones en Scala que deben cumplirse antes de continuar con cualquier código o programa. En Scala, el proceso de Diseño por Contrato (DbC) , un proceso de diseño de software da importancia y significado a las condiciones previas de Scala. El enfoque anterior fue proporcionado por Betrand Mayer y ofrece algunas condiciones posteriores y previas a un bloque de código que, si no se cumple, genera una excepción.

Las condiciones previas de Scala son un conjunto de funciones principales que tienen diferentes condiciones que un programador debe seguir al diseñar un software. Estas funciones vienen en el paquete Predef.scala y no es necesario importar ningún paquete por separado.
Los métodos son:

1. Afirmar : para afirmaciones generales
2. Suponer : enunciar un axioma
3. Requerir : verificar específicamente las entradas
4. Asegurar : es una condición posterior que también se ha cubierto.

• Afirmar

  El método Assert establece la necesidad de que se satisfaga una condición al realizar una determinada acción. Si se cumple esta condición, entonces el código funciona bien; de lo contrario, genera una excepción. Las excepciones se comprueban en tiempo de ejecución. El método assert() es, por lo tanto, una forma de verificar dinámicamente los invariantes. El método anterior toma una declaración booleana como parámetro y verifica en todo el programa si se viola en algún lugar. arroja una excepción o un error de aserción.

  Considere el siguiente programa como parte de la aprobación del proceso de solicitud de la licencia de conducir. Produce error si la edad del solicitante no es igual o superior a 18 años.

  // Code to check the age of the applicant val applicant_age = 16    // assert method calling assert(applicant_age>17)

  Si la edad supera el mínimo requerido, el proceso avanza; de lo contrario, el programa arroja una excepción como se muestra a continuación:

  Exception in thread "main" java.lang.AssertionError: assertion failed

  Buscando el código para el mismo en Predef.scala , uno encontraría un código similar al anterior:

  def assert(assertion: Boolean) {    if (!assertion)      throw new java.lang.AssertionError("assertion failed")  }

• Asumir

  Supongamos que se espera que el método sea consumido por las herramientas de análisis estático. Se supone que limita el número de condiciones que deben verificarse para la ejecución de un programa. Si se viola la condición de asumir, el verificador abandona silenciosamente el camino y no permite que el programa profundice mucho más. El método asumir() tiene la misma sintaxis que la afirmación() mencionada anteriormente, la única diferencia es su ejecución.

  El siguiente ejemplo habla de un programa que se ejecuta asumiendo que la edad del solicitante es en todo caso mayor o igual a 18 años. Se ha evitado el código principal y solo se incorpora el código que contiene la llamada a asumir().

  // Code to check the age of the applicant license_approval(17)    // Method to approve the License application def license_approval(applicant_age:Int) {      assume(applicant_age>=18) //…………… //………… //………… //The main code for checking the other details of the applicant.  //…………… //………… //………… }

  El método de asumir() le da al verificador estático un axioma en el que puede confiar. Esto reduce la carga sobre el verificador. El programa se ejecuta más profundamente en el código si se cumple la condición booleana del parámetro asumir(), de lo contrario, arroja una excepción:

  Exception in thread "main" java.lang.AssertionError: assumption failed

  El código similar se puede encontrar dentro del paquete Predef.scala:

  def assume(assumption: Boolean) {    if (!assumption)      throw new java.lang.AssertionError("assumption failed")  }

  Mientras que assert() es un método para afirmar una condición en todas las rutas de ejecución o para verificar una condición invariable a lo largo del programa, asumir(), por otro lado, se usa para reducir la carga en el analizador estático. Funciona localmente para desarrollar un mecanismo de divide y vencerás para ayudar a los analizadores a asumir una condición y revisar el código.

• Requerir:

  Este método tiene un modo innovador de tratar el problema. Por lo general, culpa a la persona que llama al método si no se cumple una determinada condición. Si la condición se cumple, el programa sigue ejecutándose, si no, lanza una excepción. La sintaxis es la misma que antes para afirmar() y asumir() siguiendo una condición booleana como parámetro. El funcionamiento de la función require() se puede mostrar con un ejemplo:
  El siguiente ejemplo muestra un método para duplicar cualquier número impar. Si el número pasado en la función es impar, funciona sin problemas, si no, se lanza una excepción.

  // Code to double the odd numbers def double_odd_numbers(number:Int) : Int = {        require(number%2==1) // Checking if the number is odd using assume method        number * 2;    }  // Calling function double_odd_numbers(13)

  Si la condición no se cumple, se lanza la siguiente excepción:

  Exception in thread "main" java.lang.IllegalArgumentException: requirement failed

  Buscando el código de excepción en Predef.scala, nos encontramos con el siguiente código:

  def require(requirement: Boolean) {    if (!requirement)      throw new IllegalArgumentException("requirement failed")  }

• Asegurar:

  Asegúrese de que es una condición posterior a diferencia de los demás. Este método generalmente se aplica junto con el método require() para hacer un programa viable. Teniendo en cuenta el ejemplo anterior en sí, podemos modificar el código agregando una condición de garantía que requiere que el número de entrada sea inferior a cierto límite.

  // Code to double the odd numbers def double_odd_numbers(number:Int, lmt:Int) : Int = {        require(number%2==1) // Checking if the number is odd using assume method        number * 2;    } ensuring(number * 2 < lmt) // Ensuring that the number produced is less than the limit.     // Calling function // The method also requires a limit [parameter to be passed.  double_odd_numbers(13, 100)

  Por lo tanto, el método afirmar() requiere que el verificador deba probar la condición que sigue como un parámetro, asumir(), por otro lado, ayuda al verificador a reducir la carga al asumir que cierta condición es cierta. Mientras que el método require() especifica la condición que debe seguir la persona que llama a la función.

  Si el programador busca eliminar las excepciones generadas por los métodos asumir() y afirmar(), se puede usar el comando -Xdisable-assertions para hacerlo.