Veamos el tipo de algunas funciones:
> String.length
<función> : String -> Int
La función String.length es de tipo String -> Int. Esto significa que debe aceptar un argumento String y, devolverá un valor Int. Intentemos asignarle un argumento:
> String.length "Supercalifragilisticexpialidocious"
34 : Int
Empezamos con una función String -> Int y le asignamos un argumento String. Esto da como resultado un valor Int.
Las funciones que aceptan varios argumentos terminan teniendo cada vez más flechas. Por ejemplo, aquí hay una función que toma dos argumentos:
> String.repeat
<función> : Int -> String -> String
Dar dos argumentos como String.repeat 3 "ja" producirá "jajaja". Parece que "->" es una forma extraña de separar argumentos, pero esto tiene una razón.
Al revisar paquetes como elm/core y elm/html, seguramente verá funciones con múltiples flechas. Por ejemplo:
String.repeat: Int -> String -> String
String.join: String -> List String -> String
¿Por qué tantas flechas? ¿Qué está pasando?
Se vuelve más claro al ver todos los paréntesis. Por ejemplo, también es válido escribir el tipo de String.repeat así:
String.repeat: Int -> (String -> String)
Es una función que toma un entero y luego produce otra función. Veamos esto en acción:
> String.repeat
<función> : Int -> String -> String
> String.repeat 4
<función> : String -> String
> String.repeat 4 "ha"
"hahahaha" : String
> String.join
<función> : String -> List String -> String
> String.join "|"
<función> : List String -> String
> String.join "|" ["rojo","amarillo","verde"]
"rojo|amarillo|verde" : String
Conceptualmente, cada función acepta un argumento. Puede devolver otra función que acepte un argumento, etc. En algún momento, dejará de devolver funciones.
Siempre podríamos poner los paréntesis para indicar que esto es lo que realmente sucede, pero empieza a ser bastante complicado cuando se tienen varios argumentos. Es la misma lógica detrás de escribir 4 * 2 + 5 * 3 en lugar de (4 * 2) + (5 * 3). Esto significa que hay algo más que aprender, pero es tan común que vale la pena.
Bien, pero ¿cuál es el propósito de esta función en primer lugar? ¿Por qué no usar (Int, String) -> String y proporcionar todos los argumentos a la vez?
Es bastante común usar la función List.map en programas Elm:
List.map : (a -> b) -> List a -> List b
Toma dos argumentos: una función y una lista. A partir de ahí, transforma cada elemento de la lista con esa función. Aquí hay algunos ejemplos:
List.map String.reverse ["part","are"] == ["trap","era"]
List.map String.length ["part","are"] == [4,3]
¿Recuerdas cómo String.repeat 4 tenía el tipo String -> String por sí solo? Bueno, eso significa que podemos decir:
List.map (String.repeat 2) ["ha","choo"] == ["haha","choochoo"]
La expresión (String.repeat 2) es una función String -> String, por lo que podemos usarla directamente. No es necesario decir (\str -> String.repeat 2 str).
Elm también utiliza la convención de que la estructura de datos siempre es el último argumento en todo el ecosistema. Esto significa que las funciones suelen diseñarse teniendo en cuenta este posible uso, lo que la convierte en una técnica bastante común.
Es importante recordar que esto puede abusar. A veces es conveniente y claro, pero creo que es mejor usarlo con moderación. Por eso, siempre recomiendo desglosar las funciones auxiliares de alto nivel cuando las cosas se complican un poco. De esta manera, tiene un nombre claro, los argumentos tienen nombre y es fácil probar esta nueva función auxiliar. En nuestro ejemplo, esto significa crear:
-- List.map reduplicate ["ha","choo"]
reduplicar : String -> String
reduplicar string =
String.repeat 2 string
Este caso es muy simple, pero (1) ahora está más claro que me interesa el fenómeno lingüístico conocido como reduplicación y (2) será bastante fácil añadir nueva lógica a la reduplicación a medida que mi programa evolucione.
En otras palabras, si su aplicación parcial se está haciendo larga, conviértala en una función auxiliar. Y si es multilínea, ¡definitivamente debería convertirse en una función auxiliar de alto nivel! Este consejo también aplica al uso de funciones anónimas.
