Currying - Part 6 of Functional Programming in JavaScript

Key Takeaways

hello what is currying currying is when a function doesn't take all of its arguments up front instead it wants you to give it the first argument and then the function returns another function which you are supposed to call with the second argument which in turn will return a new function which you are supposed to call with the third argument and so on until all the arguments have been provided and then the uh function at the end of the chain will be the one that Returns the value that you actually want does it sound confusing good the feeling of confusion is your friend it means you're learning before we get to it I'm going to incorporate some viewer feedback into the show this one is for you Joshua foreground and everything have a look at this beautiful function this function is not curried but we're going to Curry it up in just a minute it's a very simple function it takes a name a size an element all strings and returns another string let me call it and run it fluffkin is a tiny dragon that breathes lightning let's clear all thatof here is the same function in the curry version dragon is a function function that takes a name it will in turn return another function which takes size which in turn will return another function which takes an element which in turn will return the final string I'm going to call it and log the output now remember Dragon will take a name fluffy kins and it will return another function which takes a size tiny which in turn returns a third function which takes an element lightning let's run that again fluin is a tiny dragon that breathes lightning so you see that it's a chain of functions and if I just remove this last lightning call here and just ran the code it would just show that oh it's a function the idea with carrying is that your function can pass through the application and gradually receive the arguments that it needs the function goes through your app you sprinkle it with some arguments here you spice it up with an argument here and here you add the final one and and you get your output so for instance you might have broken out Dragon here into fluffin dragon and then refer to it here and you would get the same output or maybe into three parts tiny [Music] dragon and we run it again and we get the same result now our Dragon function here is written from the start to be carriable but every functional Library worth its salt has a way of making non-curable functions curable poof now dragon is back in its standard form the one we saw from the beginning the there is no currying here it's just the normal arguments as an example I'm going to use low Dash we just go mpm install low [Music] Dash install and now we can use it import from no dash there we go and then we just do Curry dragon we just overwrite the existing one bam and now fluffy kins is a tiny dragon that breathes lighting you don't have to use low Dash specifically for this all libraries with any kind of functional Nature has a curry function that's what currying is and how it works but why is it useful post production Leviosa so what you see here has no currying at all it's just normal code we're going to improve it a bit with carrying let's walk through it we have a dragons array uh we have a couple of lightning dragons here numi and fluffy kins but we also have a fire dragon and we also have a Time War Dragon that's serious business we are going to get to line 8 and nine but let's first look at line 11 and 12 where we filter out the dragon the lightning dragons from the dragon array so we just call filter on dragons you all recognize this from the previous episodes filter takes a call back which will get every item and that item will be checked against this H element function if so it it has element lightning and we pass in the object and we get a true or false and this will then be passed to lightning dragons just let me run that and you'll see that it's fluffy kins and new me that is filtered out if you look at has element it's a function that takes an element this is this string here goes here and the filtered object or the iterate the object that filter iterates goes here and just Compares that against the element property of the the object let's try to improve this with carrying let's import load out and Curry has element and then we just remove this wrapping function just do that wow so now has element is carriable that means when we call has element with lightning that means that it will return a new function which in turn expects to be passed the uh the object to check if it has element lightning which allows us to pass it as the uh callback function to filter directly which is pretty Sleek conclusion a carriable function is simply a function that takes every argument by itself and then just returns a new function that expects the next dependency to the function until all dependencies have been fulfilled and the final value is returned so we call carriable functions like this we call them with the first argument with the name which in turn will return a new function which we call with with the size which in turn will return a new function which we call with the element which will return the final value which we output here and it's car is a large dragon that breathes ice and that is Cur people as usual I would love to hear from you either on Twitter at mpj me or in a comment down below either just write something nice or funny tell me what you think could be made better or tell me what you would like to see me make a video about speaking of which make sure that you don't miss the next episode make sure that you subscribe to the channel or follow me on Twitter until next Monday stay curious