#9.2 Kotlin Tutorial for Beginners Lambdas and High Level Functions Part

hi decisions at the heart and welcome to
the next video of this module high-level
functions and lambdas now this video is
actually the continuation of the
previous video so make sure you have
watched my previous video and then only
continue with this video so in this
video we'll talk about the lambdas and
high-level functions in deep detail so
as to clear your concept with more
clarity and also we will check out
various ways to pass lambda to the high
level functions that are present in case
of Kotlin so first of all let us now
explore the lambdas and high level
functions so as seen in the previous
video the lambda expression looks like
this the curly bracket open and close
within this we have the lambda
expression now each lambda expression is
actually the function so x and y are
parameters and after the dash and arrow
operator we have X plus y which is
actually the method body so x and y are
parameter and X plus y is actually the
method body that simply returns some
value X plus y we can assign this lambda
expression to this my lambda function
variable so this is a variable of this
signature so here we have : followed by
the type of variable that we have here
now the type of variable of the lambda
expression will have the signature
similar to the expression so here x is
an integer value Y is an integer value
and then we have the return type as int
that is X plus y which is the method
body simply returns the integer value so
that is why I have written here int so
here we can say this is a variable name
and here this is the method signature or
the lambda signature that is these are
the two parameters X and Y and the
method body returns integer value that
is x and y returns the sum as integer
value now then comes the calling of the
high-level function now what is the
high-level function the high-level
function
and actually contains simply accepts the
lambda function as a parameter or it can
also return the lambda function so if a
function follows either of these two
that is accepting a lambda function or
the expression or returning some lambda
value then the method is known as the
high-level functions so this is a lambda
expression and this is the high-level
function that accepts my lambda function
right or the expression so here I have
simply defined the function add two
numbers this is the add two number and
then three comes to eight which is the
integer value it comes to be which is
again the integer value then comes my
lambda function so here I have simply
defined my function :
the signature now if you compare B : int
you will find the same thing here my
function which is actually the variable
name followed by the signature so here
the int is the signature of this B
variable so here int int followed by int
is actually the signature of this my
function so this my function actually
accepts two integer variables and then
simply returns the integer type so
inside the body of add two numbers we
can simply write our code such as my
function a comma B now here this my
function is actually this one my funk
that simply passes two parameters of a
and B so here a and B are these two
variables that has the value of three
and eight so we are simply passing three
and eight as a parameter so this a is
actually this X and this B is actually
this Y so X plus y will be evaluated in
place of my function a and B so instead
of my function a and B we can simply
evaluate it as X plus y equal to a plus
B equal to the value that is three plus
eight that simply returns 11 as a result
that is finally we are getting 11 as a
value so this 11 will be stored inside
the result variable and finally we can
simply print the result and
the output console' we will get 11 as
the output so this is all about the
lambdas and high-level functions right
so just in place of my function a and B
simply replace it mentally by this X
plus y which is the method body and put
the values as this one equal to 11 is
the result as simple as that so here
inside the IntelliJ IDE I will simply
cleaned up my code so as to make the
things more simple and more clear so now
we are only left with the add two
numbers method which is actually the
high level function that takes the
action function as a lambda expression
right and we are simply calling this
function from here program dot add two
numbers and simply passing the my lambda
expression which we saw in the previous
video so no doubt till now now here
previously we were just printing the
value that is inside the method body of
this lambda expression we are just
printing out the value now let us modify
something such as instead of s let us
say we have K comma let us say X comma Y
and then which is which is again of the
type of int x and y are int and then
here let us use X plus y right now here
as a lambda expression signature we need
to again change it so here we have two
parameters of x and y so here we will
use int comma int that is two parameters
and then the return type is actually
integer value so instead of unit we can
simply use int right now suppose if I
write here let's say a string value so
here I need to write here string as
simple as that that we saw in the
previous video as well so here let us
use int
revert it back as well let's say X plus
y that is add two numbers and now here I
am simply passing my lambda as an
expression to this add two numbers
method so I will simply modify my add
two numbers method so as to match the
signature that we have defined here
this signature so simply copy this
signature control-c and simply paste the
signature here so now we have two
parameters of int + int there simply
returns the int value right now if you
want you can also make it float as well
and change it everywhere so as of
knowledge skip it int and now here
variable sum equal to a plus B and then
whatever I do is I will simply remove
this code here and now instead of this I
am having the method of action so simply
use action and then simply pass let's
say a comma B so we do not need to have
this variable sum here as well just call
action a and B so this will simply be
evaluated as let's say the method body
now the method body is X plus y so X
plus y now here the X is actually a and
Y is actually B so the value is actually
two and seven so we can simply use a
plus B equal to implies two plus seven
now the result will be nine so this
action will again return the integer
value of nine right because the return
type is here so here I will simply
define a val result equal to action
right and now at the end print line
result so let us now run the code and
let's see what happens so here we go
nine in the output console we are
getting right so in this video we just
modified our lambda our high-level
function and also here we have the
return type as int instead of Unit and
we are simply printing out the result
inside this add two numbers method now
at the end of the previous video I told
you instead of using this whole
statement here variable my lambda and so
so we can simply cut or copy this lambda
expression from here and replace the
variable name as with the lambda
expression and simply comment this line
so here
simply passing and if you want you can
also remove this int + int signature
here x and y are the parameters and x +
y are actually the method body and
similarly here as well you can remove
the end and also end this simplifies our
code now let us run the code
so here again we get 9 in the output
console so our codes are working
perfectly fine so you can simply pass
the lambda expressions directly so this
was one way and this is another way of
calling the add two numbers that is
high-level functions now apart from
these two ways there exist two more
waves let me show you so here I have add
two numbers simply passing my lambda
function as a variable now apart from
this we can also pass the lambda
expression directly that is simply using
X Y followed by X plus y here directly
right now similar to this we have one
more alternative way that is simply used
add two numbers three and eight then
simply close the bracket now if you look
at this statement you will find the
lambda expression is actually present
right after the end of the last
parameter that is eight it is actually
looking like a method body add two
numbers and here as a method body I have
the lambda expression so instead of
closing the bracket here we are simply
closing down the bracket here and then
defining the lambda expression so these
three are actually same so all these 3
code will give the same output let me
show you the code in action inside the
IntelliJ IDE so here again let me copy
this code and paste it again let me
comment the line and now here instead of
closing the bracket here I will simply
close the bracket here by removing the
comma and now if you notice after two
and seven I am simply having the lambda
expression that appears to be the method
body right so let us run the code and
let's see what happens
so here again we get the same output as
nine so it makes no difference
so all these three lines of codes are
working perfectly fine you can use the
variable name lambda expression directly
or you can use this way of defining the
lambda expression outside the method
body like this right so this is all
about this video now we will take our
discussion to the next level in the next
video and we'll talk more about the
lambda expression and high-level
functions in case of Kotlin now remember
these two concepts are very very
important right so make sure you watch
all these videos in this module thanks
for watching and have a good day thank
you