Sobrecarga de métodos en Ruby

Una de las cosas buenas de presentarse a procesos de selección en el mundo del desarrollo de software es poder medir como está el nivel de conocimientos de uno mismo y además aprender conceptos nuevos.

En un proceso en el cual participé en Baires Dev, una de las preguntas que no pude responder fue acerca de method overloading en Ruby. Ese mismo día investigué e interioricé. Ahora trataré de explicarlo en este espacio.

Según la Wikipedia, la sobrecarga de funciones o métodos es la habilidad de crear varios métodos nombrados igual pero con diferentes implementaciones(entiéndase implementación como cuerpo de la función).

Un ejemplo de sobrecarga sería algo como:

public String printSomething() {
  System.out.println("Soy una línea");
}

public String printSomething(String texto) {
  System.out.println(texto);
}

Donde ambas funciones llevan el mismo nombre pero se ejecutan en contextos diferentes. Cuando se llama a printSomething sin parámetros esta lo que hace devolver una cadena de texto predeterminada. Al invocarse dicha función con un texto como parámetro printSomething("ola ke ace?"), la función lo que hace es imprimir el valor de ese texto en vez del predeterminado.

Sobre carga

La respuesta corta es que Ruby no soporta esta característica, sin embargo, se puede lograr con ciertas técnicas. Una de las razones por las que la sobre carga no es posible en Ruby es porque es un lenguaje de tipado dinámico, es decir que Ruby no sabe distinguir entre un argumento de tipo entero entre uno de tipo cadena (string) porque la tipificación se da en tiempo de ejecución(Ruby es un lenguaje interpretado no compilado)

Otra razón podría ser simplemente porque el creador del lenguaje no lo implementó pero en realidad es más por lo anterior 🙂

En Ruby, al tener esto:

def add(a, b)
  a + b
end

def add
  puts 'di algo'
end

y ejecutar el método add(1, 2) levanta una excepción wrong number of arguments (given 2, expected 0). Esto ocurre porque en Ruby existe es la sobre escritura y no la sobre carga. Puedes ver un ejemplo de esto en Replit.

Ahora bien, comentaba sobre unas técnicas para intentar imitar la sobre carga. La forma de hacerlo está dada por los parámetros por defecto, un hash de opciones o usando el operador splat, unario o como se le llame al asterisco puesto delante del nombre del parámetro: *splat_operator. Veamos.

Sobre carga con parámetro por defecto

En Ruby se pueden asignar valores por defecto a los parámetros, de esa forma se vuelven opcionales. Teniendo en cuenta eso podríamos hacer algo como:

def add(a = 1, b = 2)
  puts a + b
end

Con lo anterior, no hace falta escribir nuevamente la función add con diferentes parámetros. Solo hay que invocarla con la pareja de números que se quisiera sumar.

Sobre carga con un hash de opciones

Usando un hash como único parámetro de la función es mucho más sencillo ya que se puede enviar un solo parámetro pero que puede contener muchos valores. Veamos:

def add(numbers = {})
  puts numbers['first'] + numbers['second']
end

Aquí el inconveniente es que toca ponerse de acuerdo(documentar) en qué opciones tendrá el hash. Otro problema puede darse por el tipo de llave que se use en cada elemento del hash. Me refiero a que puede usarse un string o un símbolo como llave del primero o del segundo.

El método pasado puede invocarse de diferentes formas:

# Llaves string
add('first' => 1, 'second' => 2)

# Llaves símbolo
add(first: 1, second: 2)

# También con argumentos extra
add(first: 1, second: 2, third: 3, fourth: 4)

Sobre carga con el operador splat

Muy similar a usar un hash con la diferencia de que acá tendríamos un arreglo(array) y tocaría recorrerlo para leer los parámetros:

def add(*numbers)
  puts numbers[0] + numbers[1]
end

El método anterior se puede invocar de la siguiente forma:

add(1, 2, 3, 4, 5)

Pasamos una lista de valores, el método usa el 1ero y el 2do y el resto lo desecha.

La sobre carga de funciones sin duda debe tener sus ventajas y desventajas así como que Ruby carezca de este mecanismo, sin embargo, las técnicas mostradas sirven mucho para lograr un comportamiento similar sin perder la gracia y estilo que tiene el lenguaje.

Algunas fuentes:

• Struggling with Ruby
• Stack Overflow
• Imagen