{"id":87,"date":"2023-03-28T23:06:42","date_gmt":"2023-03-28T23:06:42","guid":{"rendered":"https:\/\/canessaalvamiguel.dev\/?p=87"},"modified":"2023-03-30T16:19:40","modified_gmt":"2023-03-30T16:19:40","slug":"using-partially-applied-functions-in-scala","status":"publish","type":"post","link":"https:\/\/canessaalvamiguel.dev\/index.php\/2023\/03\/28\/using-partially-applied-functions-in-scala\/","title":{"rendered":"Using Partially Applied Functions in Scala"},"content":{"rendered":"\n<p>Las funciones parcialmente aplicadas en Scala son una forma de crear nuevas funciones a partir de funciones existentes al especificar algunos de sus argumentos de antemano. Esto significa que podemos crear una nueva funci\u00f3n con una aridad reducida (n\u00famero de argumentos) a partir de una funci\u00f3n existente.<\/p>\n\n\n\n<p>La aplicaci\u00f3n parcial se logra mediante la creaci\u00f3n de una funci\u00f3n que toma algunos de los argumentos de la funci\u00f3n original y devuelve una nueva funci\u00f3n que toma los argumentos restantes. En otras palabras, una funci\u00f3n parcialmente aplicada toma una funci\u00f3n de aridad n y devuelve una funci\u00f3n de aridad m, donde m es menor que n.<\/p>\n\n\n\n<p>Veamos algunos ejemplos para entender mejor c\u00f3mo funcionan las funciones parcialmente aplicadas en Scala.<\/p>\n\n\n\n<p><strong>Ejemplo 1: Funci\u00f3n de suma<\/strong><\/p>\n\n\n\n<p>Supongamos que tenemos una funci\u00f3n <code>sum<\/code> que toma dos argumentos enteros y devuelve su suma:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code \"><pre class=\"brush: scala; title: ; notranslate\" title=\"\">\ndef sum(a: Int, b: Int): Int = a + b\n<\/pre><\/div>\n\n\n<p>Podemos crear una funci\u00f3n parcialmente aplicada que fije el primer argumento en 5 de la siguiente manera:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code \"><pre class=\"brush: scala; title: ; notranslate\" title=\"\">\nval sumaCinco = sum(5, _: Int)\n<\/pre><\/div>\n\n\n<p>Aqu\u00ed, utilizamos la notaci\u00f3n de subrayado (<code>_<\/code>) para indicar que queremos fijar el primer argumento de la funci\u00f3n <code>sum<\/code>. La nueva funci\u00f3n <code>sumaCinco<\/code> toma un solo argumento entero y devuelve la suma de 5 y ese argumento.<\/p>\n\n\n\n<p>Podemos usar esta funci\u00f3n parcialmente aplicada de la siguiente manera:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code \"><pre class=\"brush: scala; title: ; notranslate\" title=\"\">\nprintln(sumaCinco(10)) \/\/ Imprime 15\nprintln(sumaCinco(20)) \/\/ Imprime 25\n<\/pre><\/div>\n\n\n<p><strong>Ejemplo 2: Funci\u00f3n de multiplicaci\u00f3n<\/strong><\/p>\n\n\n\n<p>Supongamos que tenemos una funci\u00f3n <code>multiply<\/code> que toma tres argumentos enteros y devuelve su producto:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code \"><pre class=\"brush: scala; title: ; notranslate\" title=\"\">\ndef multiply(a: Int, b: Int, c: Int): Int = a * b * c\n<\/pre><\/div>\n\n\n<p>Podemos crear una funci\u00f3n parcialmente aplicada que fije el primer y segundo argumento en 2 y 3 respectivamente de la siguiente manera:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code \"><pre class=\"brush: scala; title: ; notranslate\" title=\"\">\nval dobleTriple = multiply(2, 3, _: Int)\n<\/pre><\/div>\n\n\n<p>La nueva funci\u00f3n <code>dobleTriple<\/code> toma un solo argumento entero y devuelve el producto de 2, 3 y ese argumento.<\/p>\n\n\n\n<p>Podemos usar esta funci\u00f3n parcialmente aplicada de la siguiente manera:<\/p>\n\n\n<div class=\"wp-block-syntaxhighlighter-code \"><pre class=\"brush: scala; title: ; notranslate\" title=\"\">\nprintln(dobleTriple(4)) \/\/ Imprime 24\nprintln(dobleTriple(5)) \/\/ Imprime 30\n<\/pre><\/div>\n\n\n<p>En resumen, las funciones parcialmente aplicadas en Scala son una forma conveniente de crear nuevas funciones a partir de funciones existentes al especificar algunos de sus argumentos de antemano. Estas funciones son \u00fatiles para crear funciones gen\u00e9ricas que pueden ser reutilizadas en diferentes contextos.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Las funciones parcialmente aplicadas en Scala son una forma de crear nuevas funciones a partir de funciones existentes<\/p>\n","protected":false},"author":1,"featured_media":62,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[16,8],"class_list":["post-87","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scala","tag-partially-applied-functions","tag-scala"],"_links":{"self":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/87","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/comments?post=87"}],"version-history":[{"count":7,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/87\/revisions"}],"predecessor-version":[{"id":108,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/87\/revisions\/108"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/media\/62"}],"wp:attachment":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/media?parent=87"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/categories?post=87"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/tags?post=87"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}