Scala "def" method declaration: Colon vs equals - function

Question

I am at the early stages of learning Scala and I've noticed different ways to declare methods.
I've established that not using an equals sign makes the method a void method (returning a Unit instead of a value), and using an equals sign returns the actual value so
def product(x: Int, y: Int) {
x*y
}
will return () (Unit), but
def product(x: Int, y: Int) = {
x*y
}
will return the product of the two arguments(x*y)
I've noticed a third way of declaring methods - with a colon. Here is an example
def isEqual(x: Any): Boolean
How does this differ from the = notation? And in what situations will it be best to use this way instead?

Answer 1

When you use colon (and use equal) you explicitly define return type of method.
// method return Boolean value
def m(a : Int) : Boolean = a > 0
When you don't use colon and use equal you allow scala compiler inferring return type itself.
// method has return type of last expression (Boolean)
def m(a : Int) = a > 0
When you use neither colon nor equal your method has return type of Unit class.
// method has Unit return type
def m(a : Int){
a > 0
}

Answer 2

Others have perfectly explained the differences between the different declarations:
def foo: Boolean = true // explicitly declare the return type
and
def foo = true // let the compiler to implicitly infer Boolean
That being said, I have to warn you against
def foo { }
This is called procedure-syntax, and you should never use it, as it's has been already deprecated (since Oct 29, 2013), although you'll get a deprecation warning only under the -Xfuture flag.
Whenever you have to declare a method returning Unit (which you should avoid as much as possible, since it means you're relying on side-effects), use the following syntax
def foo: Unit = { }
Also, as a personal advice, explicitly annotating return types makes your code often more readable and helps you in catching errors early. You know what the function should return, so explicitly annotating the type allows the compiler to check that the implementation returns an appropriate value, right at the declaration position (if you use the function you will catch an error eventually, but perhaps far from where the error really is).
Also, when declaring an abstract member, you'd better also annotate the types
trait {
def foo
}
is legal, but the type of foo is automatically inferred to be Unit, which almost never what you want.
Instead, do
trait {
def foo: Boolean
}

Answer 3

if you don't want the return type then you used
scala> def product(x: Int, y: Int) { //in lack of = it explicit uses Unit
| x*y
| }
product: (x: Int, y: Int)Unit
//equivalent to below
scala> def product(x: Int, y: Int):Unit={
| x*y
| }
product: (x: Int, y: Int)Unit
and when you write
scala> def product(x: Int, y: Int) = { //here it explicit detect return type
| x*y
| }
product: (x: Int, y: Int)Int
//equivalent to below
scala> def product(x: Int, y: Int):Int = {
| return x*y
| }
product: (x: Int, y: Int)Int

Answer 4

def foo(arg) { sideEffects() } is equivalent to def foo(arg) = { sideEffects(); Unit }. It is bad style because it hides your intention. (It's easy to overlook the missing =). I recommend you don't use it.
def foo(arg) = { expression } is a method that implicitly resolves to the type of the expression and is good style.
def foo(arg): Type is an abstract method definition with an explicit type. It is not equivalent to the other two examples, as no implementation is provided.

Answer 5

1) The procedure syntax is deprecated from scala-2.11, avoid it.
def product(x: Int, y: Int) {
x*y
}
// It always returns Unit.
// creates confusion for most beginners. deprecated for good.
2) The type inference syntax, mostly used with small/private methods.
def product(x: Int, y: Int) = {
x*y
}
It is a help from the compiler, but sometimes compiler's inference may be different from what you think.
3) The type annotation syntax.
def product(x: Int, y: Int): Int = {
x*y
}
For public APIs it is good practice to specify return type explicitly.
In some cases it is mandatory to specify return type.
For instance:
when defining recursive methods.
when compiler's inference is more specific but you need generic return type (Map in place of HashMap).
To override compiler's inference. def getId(): Long = 1
If return is used anywhere in the method body.

Answer 6

In Scala a function is defined as
def product(x: Int, y: Int): Int = {
x*y
}
but there there are few "shortcuts" that can be used
Since scala have good type Inference you can omit the type (unless the function is recursion one):
def product(x: Int, y: Int) = {
x*y
}
Everything is an expression. so function must return value. The last line of block of code is the return value. so if you use curved brackets {} the last line will be return. if the function has only one line there is no need for the curved brackets.
def product(x: Int, y: Int) = x*y
Since everything has to return a value "No value" is actually Unit. So if you dont want to return meaningful value (which mean you do some side effects) then use Unit as the return value:
def product(x: Int, y: Int): Unit = x*y
Using functions without the equal sign is just another way to return Unit (this also named "procedure syntax":
def product(x: Int, y: Int) { x*y }
Note that the procedure syntax is Deprecate and should be avoid!