[MUSIC] In this segment, we're going take curried functions and call them with too few arguments and see why that's a neat thing to do. So previously we used currying just to simulate multiple arguments. If you wanted a three argument function We used currying to have a function that returned a function, that returned a function to have three arguments. But, what if we took those same function definitions and as callers just passed in fewer arguments, one or two, instead of three. Well then what we would get back, is a closure. That's waiting, if you will, for the remaining arguments. There's no new semantics here, it's just a pleasant idiom that is completely allowed, you can always call a function that returns another function, and then, save that function and have it around, for when you want to call it. So this is called partial application. It's very convenient and useful. You can do it with any curried function, and I'm now showing you any new language constructs here. So let's do a couple examples, I've already written out all the code for this segment. So we have our two curried functions from the previous segment. We have sorted three which takes x, y, and z curried, and fold which takes f, acc, and xs curried. And now let's notice Then we can just call sorted3 with 2 arguments instead of 3. So we're going to call sorted3 with 0. That will give back a function, we'll call that with 0. We'll get back another function and then when we call that function what we'll end up doing is taking in an argument z and asking is z>=0? And is y, is 0 greater than or equal to 0. So fundamentally, what we got back was a function that takes in one argument and tells you if it's non-negative. Well, that's not the most useful function in the world, but it helps out something actually useful, like summing up all the elements in a list. Here I have a call to fold where I've also passed in 2 arguments instead of 3. So what I'm going to do is get back a function that expects a list x's. Right? It'll basically be this function here and we'll fold over it using this for fn its environment and this for the initial accumulator. So this will actually sum all the elements in the list. Now there are other ways, perhaps more intuitive to you before you've seen this. Technique ways to write this function. I could write is_nonnegative by just being a function that takes in x and call sorted3 with 0 and 0 and x or sum all the elements in the list, the same way I showed you in the previous segment where we just create a function that takes in xs And calls fold with these 3 arguments. It's just longer, right? These are pleasant, we get used to it, it's a convenient thing partial application. These are not terrible, this is not awful style. But we want you to get some practice with the sh. Shorter way, that demonstrates that you understand how currying and partial application work. And in fact, if I go back to the slides here quickly, the reason why the second version is really the same as the first version, is actually something we've seen before. Just a little bit different. This top version, is just unnecessary function wrapping. Right? We, have seen before, that, we shouldn't write fn fx = g(x) when we can just write val f = g. Well its the same thing here, except instead of having the variable g for the name of the function. We have the function that you get, by calling fold with the synonymous function. And zero. Alright? So let me show you a couple more examples I have here of just currying and partial application being useful to hopefully get the hang of it. Here's a function range which takes two arguments in a curried form. And essentially if you call Range with something like 3 comma, sorry, not comma. We're not toppling. Range 3 6, that produced the list 3, 4, 5, 6. Something like that. All right? And so if you call range with just 1 number, like, say 1 That's going to give a function back, that when you call it with a number, returns from the one up-to that number. And so, count up of, 6 where we return to the left 1,2,3,4,5,6. Just another example where we didn't need this unneccessary function wrapping version that you have here. The function range 1 is a perfectly good function, we can just say val countup = range 1. As a more useful example are iterators. Are higher order functions over lists and data structures like that, are often written in a curried form. So let me show you another example, just to sneak in another useful iterator. Here's a high order function exists, that takes a function which I'll call predicate, and a list xes. And returns true. Returns true, otherwise it returns false. So there's a simple 3 line function. The empty list should return false. There does not exist an element of the list for which predicate is true. Otherwise it's predicate applied to the first element of the list Or there exists some element in the rest of the list for which predicate returns true, so that's exists. Here's a use of it. If you call Exist with a function that checks whether its argument is seven, and a list that does not have seven, you will get false. Alright so that's the result here, is false. But much more interesting, is to take Exists, and partially apply it. A way applied to one argument will get back a function that takes a list and returns the book. So has zero does indeed have type int list arrow book and when your call has zero within int list, itwill check wether any of the elements in the list are zero, because exists with this anonymous function returns the function, Returns a closure, that given a list, checks what we want to check. Similarly, the, build in library functions in the list library provided by ML's standard library, are often written in curried form. So list dot map is actually defined for us, but it's curried. So if you call it with fun X, arrow, X plus 1. You get back a function, int list arrow int list, that will, indeed add 1 to all the elements in the list, returning a new list, and List.filter works the same way in the standard library. If I call it with this function, I will get back a list that is also an int list arrow int list, is the type of removeZeros, and the list I get back will have all the zeros. Removed from it. So that's very elegant and when you go to use these functions you have to use them in a curried form here we're using partial application. but there is one thing that I don't want to talk about right now. But unfortunately I have to. So once you start using these polymorphic curried functions with partial application, you might run into this thing called the value restriction. The value restriction is something that's NML for very good reasons, the type system would be broken without it. I don't really want to talk about it right now, 'cuz it's confusing. But you may start seeing something like warning type vars not generalized. And if you see that warning about some partial application that you have, you're not going to be able to use the function to get back. And this shouldn't surprise you have not actually done anything wrong in terms of what I have taught you so far, but you simply have to work around it. And you know no language is perfect. This is an ugly fact of life in languages like ML. So let me show you an example that might happen. Use partial application all that you want for now, it's a beautiful item. But if you do something like this. Where the result would be a polymorphic function. So I'm going to map this across something. So this could take any, the resulting function could take any kind of list and would return an alpha star int list, of the same length where I put a 1 next to every element of the list, and this will give that weird warning. And, it won't be able to be called, and how should you work around this? Well, the first way is to just, give up on the partial application, and put in, what I said was unnecessary function wrapping, but now it's a little more, necessary. If you don't like that, and you really want to do partial application, then you can put in an explicit type. That's not polymorphic, like this, and then you have a perfectly fine function but it can only be used with string lists, not with any kinds of list. I should also point out, that on homework 3, and things like that, you are not likely to run across this, because it only happens when the resulting function would be polymorphic. So for example, this call will not give any kind of warning, because we can tell from this anonymous function That it can only be applied to int-list anyway. So, just wanted to talk about that, didn't really wanted to, but in case you hit the warning, I didn't want a bunch of questions, of that thing you told me to do isn't actually working. It usually works, when you get the value instruction for things like List.map, I've given you a couple of work arounds.
