Name: カレー関数 - コンピュータマニア (Curried Functions - Computerphile)
Uploaded: 2021-01-14T10:41:37.000Z
Duration: 10 min 17 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

過去形

So a while ago, we talked about the Lunda calculus, which is a simple but powerful mathematical theory of functions.

But something we didn't talk about at the time was the idea of curried functions, which sound a bit spicy but are actually very useful.

未来形

So that's what we're gonna talk about today.

We're gonna start off with a question, and the question is what actually is a function.

So for me, a function simply takes an input on one side, processes inside and then gives an output on the right hand side so you can think of it as being a little box or little machine takes an input on one side, processes inside the box and then produces some output on the other side.

So let's have a simple example of a function on a CZ.

I'm gonna be using Haskell, but you convey, basically, do everything I'm going to show you today in any modern programming language that provide some support for the London calculus.

So example I'm going to start with is a simple increment function on.

Incremental X is X plus well so just add one toe a number so you can kind of have a look at the anatomy of this.

So the structure of this on we're doing three things were defining a name for the function we're calling Inc for increment.

We're defining a name for the input promised her eggs on.

We're explaining how the output is calculated in terms off the infant so we can have a couple of examples of this.

We could increment the number one and we get to or we could increment the number two and get three.

So let's move on towards curried functions.

Now on the first step we want to take is the idea of applying a function to a function as on in court.

Let me give you a simple example of this.

So what I'm gonna do isn't with a map the increment function that we just defined over the list from 1 to 10.

So what map is is it's a function which takes two parameters.

The first parameter is another function in this case, the little increments function that we just defined.

The second parameter is a list of things in this case, a list of numbers from 1 to 10.

And what Mom does is it takes to function here on applies it all the way across the list that were just simply incremental thing.

And all the numbers from 1 to 10 on Mum is called a higher order function because it takes a function as one of its infamous.

So let's have another example off something a bit more interesting.

Let's think about the idea off a function which has more than one input or more than one parameter so we could find a little function called Ad on.

We're gonna take two numbers x and y as inputs, and then we're going to simply add them together on the important point here is that we take the two numbers X and Y packaged up together as a pair at the same time.

Okay, so what we're gonna do then, for an example is we could add one and two and give three.

Or we could add two and three on give five.

So a curried function is a function like ad, which takes more than one input.

But rather than taking them at the same time, Packet is a pier or a triple or something like that.

So how could we redefine ad as a curried function?

We just take the brackets act So rather than saying, Ad of X Y is X plus y in brackets, we just say out of X and then it's based on.

So it looks basically the same, except we're taking the two inputs X and Y one at a time, no, rather than at the same time in a pair.

And then we can apply this function in exactly the same way as before.

And we just give it to inputs like one and two and I get three.

Or we could say, What's two and three and we get five.

Okay, so it looks basically exactly the same as the regular edition function, except rather than taking a pair of inputs at the same time, it takes to inputs one at a time so that you can say, Well, what's the point of defining functions in this curried manner?

Well, the point is that you don't need to give them all of their inputs.

So, for example, if we did add of one on, we see what it says.

So we get an error because this is still expecting its second parameter.

So if I apply, add to a single number one.

It doesn't know how to do the addition yet because we haven't given it a second number.

And that's what it's saying here is trying to print to function here.

So it says, I don't know how to show a function from integers integers or if you want a more slightly comprehensible messages, saying maybe you haven't applied a function to enough arguments.

Okay, so with the current function, which takes its input one at the time, you can partially apply it to a subset of the inputs.

So what could you actually do with a function like add one?

A list of numbers without defining a custom increment function.

Think of exes experts one and then we mapped it here.

We're using the ad function, which is curried because it takes its inputs one at the time.

And all we're doing is giving the ad function one parameter here.

And then it's a function which expects its second perimeter, and then it will map that all the way across the list.

So we get the same behavior using this general Purpose Edition function without having to define a custom increment function.

So you can ask yourself at this point what's actually going on with a curried function when I say it takes his inputs one at a time.

So let's kind of look at this definition again.

So here's the definition we had out of X Y is X plus y.

What we can do is do a simple London calculus trick here rather than having the two inputs on the left hand side of the equals.

Let's move them across the equal sign to the right hand side of the definition, and we'll do this in two steps.

So what I'm gonna do is I'm gonna say Ad of X is London.

So what I've done here is the wine is no longer on the left hand side of the definition here.

No, it's on the right hand side of the definition.

So what this is saying is, if you add a number X, then what you get is a function which is waiting for a second input.

And then it's going to give you back X plus y on this expression on the right hand side here is called a lander expression.

It's a nameless function, and it's got the same kind of anatomy as a normal function definition, except for the fact that you don't give the function in name.

We're taking an input parameter called Why We're giving back the result X plus y.

But nowhere in the blue box here have we actually given the function a name.

It's a nameless function, and then we can actually play the same game with the other input as well.

So rather than having X on the left hand side, we can move it across to the right hand side on here we have our definition or our ad function in a more primitive way, and this really lets his understand, in a quite fundamental way, what's going on with curried functions.

What we're saying is that the addition function is defined to be the function, which takes an infant called X, and what you get back is another function on that function.

Why and then gives you back the result X plus.

Why you can ask yourself, Where does this idea of currying come from?

Well, it's named after Haskell Curry, who was a mathematician on logician who studied these kind of things.

Hey, wasn't the person who actually invented this plantation on or this idea?

He attributes it to someone else called Moses, Shown Finkle, who was also a logician and mathematician working around the same time showing.

I've had to practice it quite a lot, even to be able to say it today.

It's not a word, which is very easy to say.

Where is currying kind of just trips off the tongue.