El pattern matching es una técnica para comparar estructuras de datos contra un patrón y, si coincide, extraer valores o ejecutar lógica específica. Es más expresivo que simples condicionales (if/else o switch) porque permite desestructurar objetos, listas, tuplas, enums, etc., directamente en la condición.
Digamos que es como un switch evolucionado que no solo compara valores, sino que entiende la forma y contenido de los datos.
¿Para qué sirve?
- Simplificar código: menos if anidados y menos boilerplate.
- Mayor expresividad: describe qué esperas de los datos, no cómo acceder a ellos.
- Seguridad en tiempo de compilación: muchos lenguajes obligan a cubrir todos los casos (ej. sealed classes en Kotlin, enum en Rust).
- Desestructuración directa: extraer valores sin escribir getters o índices.
En teoría el pattern matching nos obligará a escribir un código más limpio y fácil de leer, evitar errores y extraer datos directamente.
Usando otras palabras, el pattern matching (coincidencia de patrones) es como una súper versión del famoso if / else o del switch que usan muchos lenguajes de programación, pero con "esteroides".
En lugar de solo preguntar ¿Esta variable es igual a 5?, el Pattern Matching te permite preguntar:
"¿Esta información tiene la estructura o la forma que estoy buscando? Y si es así, extrae los datos que me interesan de una vez."
Pattern Matching
Observemos un ejemplo:
// Using Pattern Matching: switch(response) { case Success(data): display("Todo salió bien, los datos son: " + data) case Error(code, message): display("Error con el código " + code+ ": " + message) case Loading: display("Espere por favor...") }
Originalmente nació dentro del paradigma de programación funcional.
Actualmente está técnica se puede usar en lenguaje de programación modernos como Go, Rust, Scala, Java, Kotlin, y C#.
En Java:
switch (obj) { case String s -> System.out.println("Texto: " + s); case Integer i -> System.out.println("Número: " + i); default -> System.out.println("Otro tipo"); }
En C#:
object o = 42; if (o is int x) Console.WriteLine(x); switch (o) { case string s: Console.WriteLine($"Texto {s}"); break; case int i when i > 0: Console.WriteLine($"Positivo {i}"); break; }
En Kotlin:
sealed class Expr class Num(val value: Int): Expr() class Sum(val left: Expr, val right: Expr): Expr() fun eval(e: Expr): Int = when(e) { is Num -> e.value is Sum -> eval(e.left) + eval(e.right)}
En Go:
switch v := anyVal.(type) { case string: fmt.Println("Texto", v) case int: fmt.Println("Número", v) }
Un ejemplo sencillo de entender
Tomemos este pseudo código que verifica si la edad de una persona es igual 18. Si lo es, puede votar. Si no es el caso, no puede votar.
var edad: int = 45 if edad -equals 18 then display 'Puedes votar'. else display 'No puedes votar'. end if
Aplicando la lógica del patter matching tenemos este código en Haskell, un lenguaje puramente funcional.
votar.hs
edad :: Int edad = 45 mensaje :: String mensaje = case edad of 18 -> "Puedes votar" _ -> "No puedes votar" main :: IO () main = putStrLn mensaje
Si lo ejecutamos:
$ runghc votar.hs
La salida será:
No puedes votar
¿Acaso es un error de código? No y sí. No porque el código está haciendo lo correcto, si la edad no es 18 el usuario no podrá votar. Sí es error en cuanto a que el valor es 45 y es obvio que es mayor a 18. Debería poder votar. Modifiquemos el programa.
votar.hs
puedeVotar :: Int -> String puedeVotar edad | edad >= 18 = "Puedes votar" | otherwise = "No puedes votar" main :: IO () main = putStrLn (puedeVotar 45)
Si lo volvemos a ejecutar:
$ runghc votar.hs
La salida será:
Puedes votar
Podríamos continuar con más ejemplo, pero creo que es mejor detenernos.
El pattern matching se ha popularizado así como la programación funcional. Lenguajes como Java y C# lo implementan en sus versiones más actuales.
Es una forma que nos obliga a escribir mejor código y olvidarnos de los if anidados y complejos switch.
Enlaces:
https://en.wikipedia.org/wiki/Pattern_matchinghttps://emanuelpeg.blogspot.com/search?q=pattern+matching
