Non-explicit function returning in scala - scala

Question

I am pretty new to Scala/Functional programing ,and i am trying to figure out how to write a function that will return an function(not explicitly said that it will be function called getSometing) ,but only by set of parameters ,so basically i want to rewrite this
def plusTwo(nr : Int) : Int={
nr + 2
}
def getAlgorythm(algoName : String) = (plusTwo : Int)=>{
algoName match{
case "plusTwo" => plusTwo
}
}
To someting like this
def plusTwo(nr : Int) : Int={
nr + 2
}
def square(nr : Int) : Int{
nr * nr
}
def getAlgorythm(algoName : String) = (someFunctionThatTakesIntParam: Int)=>{
algoName match{
case "plusTwo" => plusTwo
case "square" => square
}
}
Is this non-explicit form of syntax somehow possible in Scala ? I think it should be some way, in some level this is like signing different implementations to common interface.
I am pointing here to posibility ,that if this is posible in Scala,it can be way to avoid awesome amount of reflection calls,specialy with Gui frameworks,while you are binding data.

Answer 1

I will rewrite your code in slightly cleaner style and add some fixes:
def plusTwo(nr : Int) : Int = nr + 2
def square(nr : Int) : Int = nr * nr
def getAlgorithm(algoName : String) =
algoName match{
case "plusTwo" => plusTwo _
case "square" => square _
}
Algorithm is spelled with i in English
The square method needs an = in its defintion
plusTwo and square are methods, not functions: this may be a bit confusing, but these are different constructions in Scala. Often Scala tries to blur this distinction, but unfortunately this is not one of these cases,
so, in the places we'd want to treat these methods as functions we need to postfix them with an _, which when used after a method call instructs the compiler to transform methods into functions.
To further clarify the distinction between methods and functions let's make another implementation:
val plusTwo: Int => Int = nr => nr + 2
val square = (nr: Int) => nr * nr
def getAlgorythm(algoName : String) =
algoName match{
case "plusTwo" => plusTwo
case "square" => square
}
Now, the two methods and not methods anymore, they are vals, both of type Int => Int, in other words, functions! No need to use _ this time.