Skip to main content

Expresiones infijas

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

r8vnhill/object-oriented-programming-kt
Be lazy...

Puedes ejecutar el siguiente comando para crear el módulo 

./gradlew setupInfixModule

Mientras se crean los archivos necesarios, puedes leer el código para saber qué está pasando.

Preocúpate de que el plugin infix esté aplicado en el archivo build.gradle.kts de tu proyecto.

./gradlew setupInfixModule

Preocúpate de que el nuevo módulo esté incluido en el archivo settings.gradle.kts.

En Kotlin, las expresiones infijas permiten escribir funciones de manera más legible y fluida, eliminando la necesidad de paréntesis o puntos. Estas expresiones pueden mejorar la claridad del código en casos donde las operaciones se asemejan a un lenguaje natural, como en pruebas unitarias, DSLs y operaciones sobre colecciones.

🎯 ¿Qué es una Expresión Infija?​

Una expresión infija es una función que se puede llamar sin el uso de paréntesis ni puntos, de manera similar a los operadores matemáticos. Para declarar una función como infija, se utiliza la palabra clave infix. Estas funciones infijas solo pueden ser miembros de una clase o extensiones de una clase.

💡 Sintaxis de las Expresiones Infijas​

Para definir una función infija en Kotlin, se utiliza la siguiente estructura:

class ClassName {
    infix fun functionName(parameter: ParameterType): ReturnType {
        // Cuerpo de la función
    }
}

📝 Reglas para Crear Funciones Infijas​

Para que una función pueda ser utilizada como infija, debe cumplir las siguientes reglas:

  1. Debe ser una función miembro o una extensión.
  2. Debe aceptar solo un parámetro.
  3. No debe aceptar parámetros con valores predeterminados.
// ✅ Correcto: función de extensión con un solo parámetro
infix fun String.concatenate(other: String) = this + other

// ❌ Incorrecto: función con más de un parámetro
infix fun String.concatenate(other: String, separator: String) = this + separator + other

// ❌ Incorrecto: función con un parámetro opcional
infix fun String.concatenate(other: String = "default") = this + other

⚠️ Precedencia y Ambigüedad en Expresiones Infijas​

Las funciones infijas en Kotlin pueden hacer que el código sea más legible, pero también pueden introducir ambigüedades en expresiones donde se combinan con operadores matemáticos u otras funciones infijas.

🔍 Ejemplo de Ambigüedad​

infix fun Int.multiplyBy(value: Int): Int = this * value

// ❌ Potencialmente ambiguo: ¿(3 + 5) * 2 o 3 + (5 * 2)?
val result = 3 + 5 multiplyBy 2  

println(result) // ¿16 o 13?
danger

En este caso, es difícil saber si multiplyBy tiene mayor precedencia que el +, lo que puede llevar a resultados inesperados.

✅ Solución: Usar Paréntesis​

Para evitar confusión, siempre es recomendable usar paréntesis cuando se mezclan operadores estándar con funciones infijas:

// 🚀 Opción clara y sin ambigüedad
val result1 = (3 + 5) multiplyBy 2  // (3 + 5) * 2 = 16
val result2 = 3 + (5 multiplyBy 2)  // 3 + (5 * 2) = 13

🏆 Caso de estudio: Expresiones infijas en Kotest​

Un uso común de expresiones infijas en Kotlin es en frameworks de pruebas, como Kotest, donde ayudan a escribir assertions más legibles y expresivas.

Por ejemplo, en una prueba unitaria, podemos verificar la longitud mínima de un nombre de usuario usando Kotest y una expresión infija.

🔄 Comparación: Expresión Infija vs. Función Normal​

Veamos cómo se vería una prueba usando una función estándar frente a una expresión infija:

// ❌ Sin expresión infija (función estándar)
username.shouldHaveMinimumLength(5)

// ✅ Con expresión infija
username shouldHaveMinimumLength 5

🎯 ¿Por qué la versión infija es mejor?​

  1. Legibilidad mejorada → La sintaxis infija imita una oración natural, lo que hace que las pruebas sean más fáciles de leer y entender.
  2. Menos ruido visual → Se eliminan los paréntesis innecesarios, haciendo que la intención del test sea más clara.
  3. Mayor expresividad → Se asemeja a un lenguaje natural, lo que es especialmente útil en DSLs de testing.

✍ Implementación en Kotest​

infix fun Username.shouldHaveMinimumLength(length: Int): Username {
    this should haveMinimumLength(length)
    return this
}
¿Qué acabamos de hacer?
  • Uso de expresiones infijas → La función shouldHaveMinimumLength se define como infija para hacer que la prueba sea más legible y expresiva.
  • Compatibilidad con Kotest → Se integra con should, manteniendo la coherencia con el estilo del framework.
  • Retorno fluido → Se devuelve la propia instancia (this) para permitir encadenamiento de validaciones si es necesario.

🧪 Uso de la Función en Pruebas Unitarias​

El uso de shouldHaveMinimumLength en pruebas unitarias facilita la generación de valores aleatorios para verificar esta condición:

checkAll(
    Arb.int(0..10).flatMap { length ->
        Arb.usernames()
            .filter { it.value.length >= length }
            .map { length to Username(it.value) }
    }
) { (length, username) ->
    username shouldHaveMinimumLength length
}
checkAll(
    Arb.usernames().flatMap { username ->
        Arb.int(username.value.length + 1..100)
            .map { it to Username(username.value) }
    }
) { (length, username) ->
    shouldThrow<AssertionError> {
        username shouldHaveMinimumLength length
    }
}
¿Qué acabamos de hacer?
  • Generación de valores aleatorios: Creamos nombres de usuario aleatorios con diferentes longitudes para validar el matcher.
  • Uso de shouldHaveMinimumLength: La función infija se emplea para verificar fácilmente si un nombre de usuario cumple con la longitud mínima.
  • Manejo de excepciones: Cuando un nombre de usuario no cumple con la longitud mínima, el test lanza una excepción como se espera.

📊 Beneficios y Limitaciones de las Expresiones Infijas​

Beneficios

  • Mayor legibilidad: Las expresiones infijas hacen que el código sea más intuitivo y fácil de leer, especialmente en casos como pruebas o DSLs, donde se busca un lenguaje natural y expresivo.
  • Ideal para operadores personalizados: Facilitan la creación de operadores personalizados que se comporten de manera similar a los operadores incorporados, sin necesidad de sobrecargar operadores preexistentes.
  • Compatibilidad con librerías de pruebas: En bibliotecas de pruebas como Kotest, las expresiones infijas mejoran la claridad y comprensión de los casos de prueba al representar directamente el comportamiento esperado.
  • Simplicidad en la implementación: Implementar una función infija solo requiere cumplir algunas reglas simples, permitiendo a quien desarrolla a personalizar operaciones sin complicaciones adicionales.
  • Facilita la escritura de DSLs en Kotlin, donde se busca una sintaxis cercana al lenguaje natural.
  • Reduce la necesidad de sobrecargar operadores, permitiendo definir funciones con una sintaxis más expresiva.

Limitaciones

  • Limitaciones en parámetros: Las funciones infijas solo aceptan un parámetro, lo que limita su aplicabilidad a casos específicos y podría no ser suficiente en operaciones que requieren varios argumentos.
  • Ambigüedad potencial: En situaciones complejas, las expresiones infijas pueden introducir ambigüedad en la precedencia de operaciones, especialmente cuando se combinan múltiples expresiones infijas en una sola línea.
  • Menor reusabilidad en ciertos contextos: Dado que están pensadas para operaciones simplificadas y expresivas, las funciones infijas pueden no ser ideales para lógica compleja o de múltiples pasos.
  • Puede hacer el código menos predecible si se abusa de ellas sin una convención clara.
  • Menor compatibilidad con Java, ya que las funciones infijas no son idiomáticas en otros lenguajes de la JVM.

📌 Conclusiones​

Las expresiones infijas en Kotlin son una herramienta poderosa que permite escribir código más expresivo y legible, eliminando la necesidad de paréntesis y puntos en ciertas operaciones. A lo largo de esta lección, exploramos sus beneficios, limitaciones y casos de uso, con énfasis en su aplicación en DSLs y frameworks de pruebas como Kotest.

🔑 Puntos clave​

  1. Expresividad y legibilidad mejorada
    • Las expresiones infijas permiten escribir código más cercano al lenguaje natural, lo que mejora su comprensión y mantenimiento.
    • Son especialmente útiles en DSLs, frameworks de pruebas y APIs declarativas.
  2. Uso en Kotest y DSLs
    • En pruebas unitarias, las expresiones infijas ayudan a escribir assertions más claras, como: 
      username shouldHaveMinimumLength 5
    • Esto mejora la legibilidad y hace que las pruebas sean más autoexplicativas en comparación con llamadas de función tradicionales.
  3. Reglas y limitaciones
    • Una función infija debe ser miembro o extensión de una clase, aceptar un solo parámetro y no tener valores predeterminados.
    • No se recomienda su uso excesivo, ya que pueden hacer el código menos predecible si no se utilizan con claridad.
  4. Precedencia y ambigüedad
    • Las expresiones infijas pueden generar ambigüedad cuando se combinan con operadores matemáticos u otras funciones infijas.
    • Se recomienda usar paréntesis para evitar confusión en expresiones compuestas: 
      val result = (3 + 5) multiplyBy 2  // Sin ambigüedad
  5. Comparación con funciones tradicionales
    • Aunque mejoran la fluidez del código, no siempre son la mejor opción.
    • Para casos en los que se necesiten múltiples parámetros, es preferible una función estándar.

✅ Reflexión final​

Las expresiones infijas ofrecen una sintaxis elegante que hace el código más legible en contextos adecuados, como DSLs y frameworks de pruebas. Sin embargo, deben usarse con criterio, evitando ambigüedades y asegurando que realmente aporten claridad al código.

En proyectos donde la expresividad es clave, como bibliotecas de pruebas o APIs de alto nivel, las funciones infijas pueden hacer una diferencia significativa en la calidad del código.

Understanding Kotlin Infix Functions: A Detailed Guide. (s. f.). Recuperado 18 de marzo de 2025, de https://www.dhiwise.com/post/understanding-kotlin-infix-functions-a-beginners-guide

Bibliografías Recomendadas

    Bibliografías Adicionales

    Scala