This week we’ll be covering the process of partially applying parameters to a subroutine, this is based off of closures which we covered last week. This allows us to create new subroutines that we can pass around that already have some of their parameters defined. One of the benefits of this is that we don’t have to pass around a parameter list and wait until all the parameters are ready, instead we can apply each parameter as we get it and then execute the subroutine at some later time when we are ready. Doing this in Perl is actually very simple.
The function above provides us the ability to curry other functions. Analyzing it shows that all we are doing is creating a new anonymous function that is going to call the function we passed in with the parameters we passed in and the parameters it receives. Let’s see an example of how this would work.
So, let’s look at how it all worked. First, we made a new anonymous function that takes a list of parameters, joins them, and prints them. Next we curried that list with 3 fruit. To do this we created a new anonymous subroutine that passed in the three fruit into the first anonymous subroutine. After that we repeated the process, by currying the new subroutine we created from the last curried we now have a subroutine that calls the subroutine created on line 3 with 2 new fruit, that subroutine calls the subroutine created on line 1. Once we execute this we will output a list of all the fruit we’ve given to the function.
We don’t have to only curry anonymous functions. Because we can get the reference of named functions and builtins we can also curry those.
This concludes this week’s lesson. Next week we will move past the building blocks of functional programming and start getting into systems built on top of this functional foundation. Next week we’ll cover dynamic dispatch tables.