 <p>The compiler attempts to resolve implicits before eta-expansion of <code>from</code> into a function, so the type parameters of <code>from</code> are not yet inferred when you call it like this:</p> <pre><code>future.map(from) </code></pre> <p><code>compiles2</code> obviously works because you supply the type parameters on your own. When you call <code>future.map(from[C1, C2])</code>, the compiler knows it will need an implicit <code>C1 =&gt; C2</code>, because that's what you've told it.</p> <p>With <code>compiles1</code>, the difference is a little more subtle, but it stems from the fact that <code>future.map(from)</code> and <code>future.map(x =&gt; from(x))</code> are actually very different things. The former uses eta-expansion, which fails for the aforementioned reasons. With <code>future.map(x =&gt; from(x))</code>, there is no eta-expansion happening. Instead, you have an anonymous function that simply <em>calls</em> <code>from</code> instead of eta-expanding it. Therefore, the compiler can infer the type of <code>x</code>, which tells us that <code>x</code> is a <code>C1</code> (in this case), and it can find the implicit conversion <code>c1ToC2</code> that satisfies the type parameters of <code>from</code> while resolving the implicit and the final return type of the method, <code>Future[C2]</code>.</p>