title: Why does apply with function parameter fail for println and not print?
body: <p>When I passed a callback function into the apply method like so, I got compilation errors.</p>
  
  <pre><code>Foo[Int](println) // Error: overloaded method ... cannot be applied to (Unit)Foo[Int](println)
  Foo[Int](f = println) // Error: overloaded method ... (f: Unit)Foo[Int](f = println)
  Foo[Int]((x:Int) =&gt; println(x)) // Works!
  </code></pre>
  
  <p>At first I thought this was due to missing argument list because it works for <code>print</code></p>
  
  <pre><code>Foo[Int](print(_)) // works
  Foo[Int](f = print(_)) // works
  Foo[Int]((x:Int) =&gt; print(x)) // works
  </code></pre>
  
  <p>But adding this still fails for <code>println</code></p>
  
  <pre><code>Foo[Int](println(_)) // Error:(6, 18) missing parameter type for expanded function ((x$1: &lt;error&gt;) =&gt; println(x$1)) Foo[Int](println(_)) 
  Foo[Int](f = println(_)) // Error:(7, 22) missing parameter type for expanded function ((x$2: &lt;error&gt;) =&gt; println(x$2)) Foo[Int](f = println(_))
  Foo[Int]((x:Int) =&gt; println(x)) // works
  </code></pre>
  
  <p>Why don't the two first ways of passing in the println function work?
  Is it the overloading of <code>println()</code> and <code>println(x: Any)</code> that causes problems for the compiler?</p>
  
  <p>Below is a full example with companion object and case class for Foo as well as some other reactive stream code</p>
  
  <pre><code>package test
  
  import org.reactivestreams.{Subscriber, Subscription};
  
  object test extends App {
    Foo[Int](println) // Error: cannot be applied to (Unit)Foo[Int](println)
    Foo[Int](f = println) // Error: (f: Unit)Foo[Int](f = println)
    Foo[Int]((x:Int) =&gt; println(x)) // Works!
  }
  
  object Foo {
    def apply[T](f: T =&gt; Unit): Foo[T] = new Foo(
      new Subscriber[T] {
        override def onSubscribe(s: Subscription): Unit = {}
        override def onNext(t: T): Unit = f(t)
        override def onError(t: Throwable): Unit = {}
        override def onComplete(): Unit = {}
      }
    )
  }
  case class Foo[T] (delegate: Subscriber[T]) extends Subscriber[T] {
    override def onSubscribe(s: Subscription): Unit = {}
    override def onNext(t: T): Unit = {}
    override def onComplete(): Unit = {}
    override def onError(t: Throwable): Unit = {}
  }
  </code></pre>