Pattern matching

Pattern Matching nace del paradigma funcional aunque hoy en día lenguaje multiparadigma lo implementan como Scala o Kotlin. Pattern Matching permite definir funciones por medio de macheo de parámetros y resultados.

Veamos un ejemplo en Haskell de definición de factorial:

 factorial 0 = 1
 factorial n = n * factorial (n - 1)

Para ver la diferencia entre la forma de resolver el problema sin Pattern Matching, voy a resolver lo mismo en C++

 int factorial(int n) {
       if (n == 0) {
              return 1;
       } else {
             return n * factorial(n-1);
       }
 }

Si comparamos nos ahorramos 5 lineas; pero el tema no es solo escribir menos código. Además debemos pensar: ¿Cuál les parece más legible? ¿Cuál es más simple?

Muchos lenguajes implementan Pattern Matching, al venir del paradigma funcional normalmente los lenguajes funcionales como Erlang lo implementan; vamos a hacer la función de factorial en Erlang.

 fac(0) -> 1;
 fac(N) when N > 0, is_integer(N) -> N * fac(N-1).

Se puede ver que en este caso se indica que debe ser positivo el número; si se ingresa un valor negativo lanza un error. Ojo estas restricciones también la podíamos hacer en Haskell.

Factorial con ML se vería de la siguiente manera:

 fun fac 0 = 1
      | fac n = n * fac (n - 1)

Otros lenguajes multiparadigma nos permiten jugar con Pattern Matching como Scala:

 def fact(n: Int): Int = n match {
     case 0 => 1
     case n => n * fact(n - 1)
   }

En este caso se define fact que devolverá un entero, y que el parámetro n debe coincidir con 0 y devuelve 1 o con cualquier otro valor y devolverá n * fact(n - 1).

Por ejemplo Kotlin permite hacer Pattern Maching por tipo de la siguiente manera:

 when (x) {
   is Int -> print(x)
   is List -> print(x.sum())
   !is Number -> print("No es un número")
   else -> print("No puedo hacer nada")
 }

Para citar otro ejemplo, veamos desarrollar una función que indique el número que se encuentra en una posición indicada por parámetro de la secuencia de Fibonacci, y lo desarrollaremos con F# :

 let rec fib n =
     match n with
     | 0 -> 0
     | 1 -> 1
     | 2 -> 1
     | _ -> fib (n - 1) + fib (n - 2)

Si lo comparamos con Mathematica:

 fib[0]:=0
 fib[1|2]:=1
 fib[n_]:= fib[n-1] + fib[n-2]

En Mathematica podemos utilizar el | para decir esto o aquello y el _ para indicar cualquier otro valor.

Pattern Matching es una técnica muy simple, pero muy potente. Por ejemplo necesitamos el primer elemento de una lista podemos definirla de la siguiente manera, vamos a implementarlo en Haskell:

primero :: [a] -> a
primero [] = error "¡No puedes utilizar la función primero con una lista vacía!"
primero (x:_) = x

Con (x:_) estamos diciendo que puede llegar una lista por parámetro que está conformada por un elemento y el resto. Implementemos la función cantidadDeElementos que nos indique cuantos elementos tiene una lista:

cantidadDeElementos :: (Num b) => [a] -> b
cantidadDeElementos [] = 0
cantidadDeElementos (_:xs) = 1 + cantidadDeElementos xs

Conclusión

Una desventaja del uso de Pattern Matching es que nuestro código se verá muy afectado ante un cambio en las estructuras. Pero la ventajas son muchísimas, para citar algunas: legibilidad de código, simplicidad, menos lineas de código, etc...

Más información | Pattern Matching