- [Shaun] So what is partial application?

- ショーン】 では、部分適用とは何でしょうか？

Well, in simple terms,

まあ、わかりやすく言えば

partial application is when we take a function

部分適用とは、関数を

that has some number of arguments,

は、ある数の引数を持つ。

and we fix some of those arguments to a set value.

で、その引数のいくつかを設定値に固定するのです。

This function with fixed arguments

この関数に固定引数を与えると

can then be called from anywhere else in the code,

は、コード内の他のどこからでも呼び出すことができます。

and it'll be as if we had called the original function

を呼び出すと、あたかも元の関数を呼び出したかのようになります。

with all of its arguments.

を、その引数のすべてと一緒に使用します。

Another way to think about it as like this:

もうひとつ、こんな考え方もあります。

Normally when we call a function,

通常、関数を呼び出すときは

we have to pass all the arguments into it

すべての引数を渡さなければならない

at the same exact time in place.

を、同じ場所で、同じ時間に。

What partial application allows us to do,

部分適用でできること

is pass arguments to a function,

は関数に引数を渡すことです。

at different places in the code,

をコード内の異なる場所に配置しました。

and then get the result,

を実行し、その結果を取得します。

once the function gets all of the arguments it needs.

は、関数が必要な引数をすべて取得した後、その引数を返します。

Now, partial application is also a very useful way

さて、部分適用も非常に便利な方法です

to configure more general functions

より一般的な機能を設定するために

into more specific ones.

をより具体的なものにする。

In general,

一般的には

if there's a function that we use often in our code,

コードでよく使う関数があれば。

where one or more of the arguments that we call it with

で呼び出す引数のうち、1つまたは複数の引数を指定します。

is almost always the same,

はほとんど同じです。

this is usually a good candidate

これは、通常、良い候補

for using partial application.

部分的なアプリケーションを使用するためのものです。

So now that we know what partial application is,

さて、部分適用がどういうものかわかった。

what exactly does it look like in code?

具体的にどのようなコードになるのでしょうか？

Well, let's imagine that we have a simple add function,

さて、簡単なadd関数があるとします。

that takes three integers as arguments,

は，3つの整数を引数として受け取る。

and adds them together.

を追加していきます。

That would look something like this:

それは、次のようなことです。

We're going to say, try function,

機能を試せということです。

using this try function interface

このtry関数インターフェイスを使用して

that we defined earlier in the course.

を定義しました。

And it's going to take three integers as arguments.

そして、引数として3つの整数を受け取ることになる。

So integer, integer, integer,

だから、整数、整数、整数。

and it's going to return an integer as well.

で、これも同様に整数を返します。

We'll just call this function add.

ここでは、この関数をaddと呼ぶことにします。

And what it's going to do is,

そして、それが何をするかというと

it's going to take its three arguments,

その3つの引数を取ることになるのです。

and add them all together, okay?

を加えて、全部一緒にしてください、いいですね？

So now that we have this function,

さて、これでこの機能ができました。

what if we wanted to fix one of these arguments

これらの引数のうち1つを修正したい場合はどうすればよいのでしょうか。

to a certain number,

を一定の数値にする。

so that we only had to pass in the other two arguments

ということで、残りの2つの引数を渡すだけでよかったのです。

later on?

後日談

Well, what that would look like is this:

まあ、どんなものかというと、こんな感じです。

We would create another function

別の関数を作成することになります。

using the function interface,

機能インターフェイスを使用して

and this function will take a single integer as an argument,

で、この関数は引数として1つの整数を受け取ります。

and it'll return a BiFunction

を返せば、BiFunction

that takes two integers as arguments,

は，二つの整数を引数として受け取る。

and returns an integer.

を受け取り、整数を返します。

And we have to import both the BiFunction

そして、BiFunctionの両方をインポートする必要があります。

and function interfaces up at the top.

と機能インターフェイスを上部に配置しました。

And for the name of this function,

そして、この機能の名前には

we're going to call it addPartial.

ここでは、addPartialと呼ぶことにします。

And what this function is going to do,

そして、この機能が何をしようとしているのか。

is it's going to take a single argument,

は、引数を1つ取ることになります。

and it's going to return another function

という関数が返されます。

that takes the other two arguments.

であり、他の2つの引数を取る。

And finally, once it has all of those three arguments,

そして最後に、この3つの引数が揃ったところで。

it's going to call add dot apply, with x, y, and z.

は、x、y、zを指定して、add dot applyを呼び出そうとします。

So now that we have this addPartial function,

さて、これでaddPartial関数ができました。

calling it is going to look like this:

と呼ぶと、このような感じになります。

We're going to say BiFunction, integer, integer, integer,

BiFunction、integer、integer、integerと言うことにしています。

and we'll say something like

というような言い方をします。

add five equals addPartial dot apply five.

add five equals addPartial dot apply five.

So now the first argument x has been fixed to five,

これで第1引数のxは5に固定されたわけだ。

by calling add partial dot apply five.

は、add partial dot apply fiveを呼び出すことで実現します。

And what we can do now is we can call this add five function

そして、今できることは、このadd five関数を呼び出すことです。

with the other two remaining arguments.

を、残りの2つの引数で指定します。

And I'm going to print this out,

そして、これをプリントアウトする。

so you can see what it looks like.

ということで、どのようなものか見てみましょう。

So we can say add five dot apply,

だから、5つのドットを適用することを追加すると言うことができます。

and we can call it with the remaining two arguments,

で、残りの2つの引数で呼び出すことができます。

which are going to be y, and z here.

は、ここではy、zになります。

And if we run this code,

そして、このコードを実行すると

we'll see that it prints out the correct result.

が正しい結果をプリントアウトすることを確認します。

So this is five plus six plus seven,

つまり、これは5＋6＋7なんですね。

except we passed in the five and the six and seven

ただし、5人、6人、7人でパスした。

in different places in our code.

をコード内の別の場所に配置しました。

And that's what partial application is.

そして、それが部分適用なのです。

So in this example that we just went through,

つまり、先ほどの例では

we fixed the first argument x,

は、第1引数のxを固定しました。

and left the other two for later.

で、残りの2つは後回しにしました。

But in reality,

しかし、現実には

we can divide up our arguments however we want.

というように、好きなように議論を分担することができます。

For example,

例えば、こんな感じです。

we could pass in the first two arguments,

は、最初の2つの引数を渡すことができました。

and leave the last one for later.

で、最後の1枚は後回し。

And that would look something like this:

そして、それは次のようなものでしょう。

We'd say function,

機能ということになりますね。

and it would take two arguments and return a function,

で、2つの引数をとって関数を返すというものでした。

that takes an integer as an argument,

は，引数として整数をとる。

and returns an integer.

を受け取り、整数を返します。

And what this would look like now,

そして、これが今どうなっているのか。

is it would take the first two arguments, x and y,

は、最初の2つの引数、xとyを取ることになります。

and return a function that takes the last argument.

で、最後の引数を取る関数を返します。

And then it would call add dot apply,

そして、add dot applyを呼び出すのである。

with those three arguments we'd accumulated.

その3つの議論を積み重ねながら

Oh, and this would actually be a BiFunction,

それと、これは実はBiFunctionになるんです。

instead of just a regular function.

を通常の関数ではなく

So now calling this is going to look a little bit different.

だから、今これを呼ぶと、ちょっと違う感じになるんです。

We're going to say, function,

私たちは、機能という

since that's what this returns here,

というのが、ここで返されるものなので。

function, integer, integer,

関数、integer、integer。

and we'll call this add five and six,

で、これをadd 5 and 6と呼ぶことにします。

equals addPartial dot apply,

equals addPartial dot apply,

with y and z equal to five and six, okay?

yとzは5と6に等しい、いいか？

So what we're doing here is,

だから、ここでやっていることは

we're setting x to five and y to six,

xを5に、yを6に設定しています。

so that we only have to pass in z later on, okay?

そうすれば、後でzでパスすればいいだけだから、ね？

So what we can do now,

だから、今できること。

again, I'm going to print this out to the console,

もう一度、コンソールに出力してみます。

is we can call add five and six dot apply,

は、add 5と6ドットの適用を呼び出すことができます。

with the final argument z,

を最後の引数zで指定します。

which we're going to say seven.

を7つとする。

And if we run this program again,

そして、このプログラムをもう一度実行すると

we see that it prints out the same answer,

と表示され、同じ答えがプリントアウトされることがわかります。

except we're just passing our arguments

ただし、引数を渡すだけです。

in a different order now.

を、今度は違う順番で。

And we also don't even have to pass in our arguments

また、引数を渡す必要もありません。

in the same order as we have here, right?

という順番になりますよね？

We could pass in z and x here,

ここでzとxを渡せばいいんです。

and we could pass in the middle argument y later on,

と、後から途中の引数yでパスすることができました。

or we could say y and x and pass z later on,

とか、yとxと言いながらzを後からパスすることも可能です。

we could do it in pretty much whatever order we want.

ということで、順番は自由です。

And obviously, in this case,

そして明らかに、この場合。

that wouldn't make much of a difference,

というのは、あまり大きな違いはないでしょう。

since the order doesn't matter of our arguments,

というのも、私たちの議論では順番は関係ないからです。

but there are some cases where that would make a difference.

が、それで差が出るケースもある。

So I'm just going to change these back

だから、これらを元に戻すだけです

to the way they were before.

を以前の状態に戻す。

And one last thing that I want to talk about,

そして、最後にもう一つ、お話したいことがあります。

is that we could even go a level deeper with our functions,

は、さらに一歩踏み込んだ機能を実現することができるのです。

and do something like this,

というようなことをします。

where we have a function that takes the first argument,

ここで、最初の引数を取る関数があります。

and returns a function that takes a second argument,

を受け取り、第二引数を取る関数を返します。

and returns a function that takes the third argument,

を受け取り、第3引数を取る関数を返します。

and finally, that returns the answer.

で、ようやくその答えが返ってくる。

Now, obviously, talking about these things

今、明らかに、これらのことを話すと

can sound a little confusing sometimes.

は、ちょっとわかりづらいと思うこともあります。

So what this is going to look like is,

では、これがどのようなものかというと

it's going to be a function,

機能することになります。

that takes an integer as an argument,

は，引数として整数をとる。

and returns a function

という関数が返されます。

that takes an integer as an argument,

は，引数として整数をとる。

that returns a function, and takes an integers and argument,

は，関数を返す関数で，整数と引数を取る。

and finally returns an integer, okay?

で、最後に整数を返すんだ、いいね？

Now that might look really confusing, and it kind of is,

今のは本当に分かりにくいと思うかもしれませんし、実際そうなんです。

but this is just a fun example to go through.

が、これはあくまで楽しい例として、スルーしてください。

So bear with me.

だから、我慢してください。

So what this would look like now,

では、これが今どうなっているかというと。

is we would define a function

を定義します。

that takes an integer as an argument,

は，引数として整数をとる。

and returns a function that takes an integers and argument,

を受け取り、整数と引数を取る関数を返します。

and returns an integer.

を受け取り、整数を返します。

And we could call this add five.

そして、これをアド・ファイブと呼ぶこともできる。

And we'd say that that's equal to addPartial dot apply,

そして、それはaddPartial dot applyと等しいと言うことになります。

and pass in the first argument five.

で、第一引数5を渡す。

And then we could say function, integer, integer,

そして、関数、整数、整数と言うことができる。

add five and six is equal to add five dot apply,

5と6を足すと、5のドットを足すのと同じになります。

and pass it in the second argument.

を作成し、第2引数で渡します。

And finally, we could say integer

そして最後に、整数を言うことができる。

sum equals add five and six dot apply,

sum equals add five and six dot apply,

and pass in the last remaining argument, which is seven.

で、最後に残った引数である7を渡します。

And if we print out the sum here,

そして、ここで和をプリントアウトすると

we see that that gives us the exact same answer,

を見ると、全く同じ答えが返ってくることがわかります。

except obviously this is much more confusing.

ただし、明らかにこちらの方が分かりやすいですね。

Now this specific case,

さて、この具体的なケース。

where we pass in our arguments one at a time,

ここで、引数を一つずつ渡していきます。

is something called currying.

は、カレーと呼ばれるものです。

And currying is just a special case

そして、カレーはあくまで特殊なケース

for partial application, again,

を、再び部分適用に。

where each of the arguments has passed in one at a time,

ここで、各引数は一度に一つずつ渡されました。

instead of in groups like we saw before.

を、以前のようにグループ単位ではなく、グループ単位で表示するようにしました。

(bright music)

(明るい音楽)