Scala Currying syntax explanation - scala

Question

I am new to scala .
I want to understand the syntax of this below code
object PlainSimple {
def main(args:Array[String])
{
val m = add(5)
println(m(3))
}
def add(x:Int):Int=>Int =
{
y=>y+x
}
}
My question is where are we saying that the add function is returning another function?
What does Int=>Int mean?
Inside the add function what is called y? Why are we using it without declaring it anywhere?
What do need to do if want multiples line inside add method?

Answer 1

My question is Where are we saying that the add function is returning another function?
Right here
def add(x: Int): Int => Int = y => y + x
Int => Int is a function type. That's just syntactic sugar, but you can also write it as
def add(x:Int): Function1[Int, Int] = y => y + x
Now, what is y? y => y + x is a lambda, i.e. an anonymous function. This lambda takes one parameter that we're now referring to as y.
Here's a good reference on anonymous functions in scala and their syntax: http://docs.scala-lang.org/tutorials/tour/anonymous-function-syntax.html
In order to have multiple lines inside the method just use braces
def add(x:Int): Function1[Int, Int] = { y =>
println("whaveter")
y + x
}

Answer 2

My question is Where are we saying that the add function is returning another function?
What is Int=>Int means?
T => U as a type means "a function that takes a T and returns an U". So when we write : Int => Int at the end of the function signature, we say "this function returns a function from Int to Int".
Inside the add function what is called y ? Why are we using it without declaring it anywhere?
As an expression x => body (or (x,y,z) => body for multiple parameters) is a function literal, that is it defines an anonymous function whose parameter is named x and whose body is body. So we are declaring the parameter x by writing its name of the left side of the =>.
What do need to do if want multiples line inside add method?
You can put anything to the right of => that you could also put to the right of = when defining a method using def. So if you want your function's body to consist of multiple statements, you can use braces just like with a regular method definition:
y => {
val z = y+x
z*2
}