Question: 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:

1. [Difference between function with parentheses and without](https://stackoverflow.com/q/7600910/293064)
2. [Scala methods with no arguments](https://stackoverflow.com/q/6939908/293064)

Answer: 
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.
To answer your second question, just add an `_`:

```
scala> def foo = println("foo!")
foo: Unit

scala> def test(arg: () => Unit) = { arg }
test: (arg: () => Unit)() => Unit

scala> test(foo _)
res10: () => Unit = <function0>

scala> test(foo _)()
foo!

scala>            

```