What is the difference between def foo = {} and def foo() = {} in Scala?
functional-programming, jvm, jvm-languages, programming-languages, scala
Solution
If you include the parentheses in the definition you can optionally omit them when you call the method. If you omit them in the definition you can't use them when you call the method.
scala> def foo() {}
foo: ()Unit
scala> def bar {}
bar: Unit
scala> foo
scala> bar()
<console>:12: error: Unit does not take parameters
bar()
^
Additionally, you can do something similar with your higher order functions:
scala> def baz(f: () => Unit) {}
baz: (f: () => Unit)Unit
scala> def bat(f: => Unit) {}
bat: (f: => Unit)Unit
scala> baz(foo)
scala> baz(bar)
<console>:13: error: type mismatch;
found : Unit
required: () => Unit
baz(bar)
^
scala> bat(foo)
scala> bat(bar) // both ok
Here `baz` will only take `foo()` and not `bar`. What use this is, I don't know. But it does show that the types are distinct.
Problem
Given the following constructs for defining a function in Scala, can you explain what the difference is, and what the implications will be? ``` def foo = {} ``` vs. ``` def foo() = {} ``` Update Thanks for the quick responses. These are great. The only question that remains for me is: If I omit the parenthesis, is there still a way to pass the function around? This is what I get in the repl: ``` scala> def foo = {} foo: Unit scala> def baz() = {} baz: ()Unit scala> def test(arg: () => Unit) = { arg } test: (arg: () => Unit)() => Unit scala> test(foo) <console>:10: error: type mismatch; found : Unit required: () => Unit test(foo) ^ scala> test(baz) res1: () => Unit = <function0> ``` Update 2012-09-14 Here are some similar questions I noticed: - Difference between function with parentheses and without - Scala methods with no arguments