What the @*!% is with the '_'

1. scala> import java.io._ // 1
2. import java.io._
4. scala> import java.io.{ File => _ } // 2
5. import java.io.{File=>_}
7. scala> object MyObj{ def count=(1 to 10) }
8. defined module MyObj
10. scala> import MyObj._ // 3
11. import MyObj._
13. scala> class MyClass { def countDown= 10 to 5 by -1} 
14. defined class MyClass
16. scala> val instance = new MyClass()
17. instance: MyClass = MyClass@69ebcd0
19. scala> import instance._ // 4
20. import instance._
22. scala> def multiply(by:Int,x:Int)=2*x
23. multiply: (Int,Int)Int
25. scala> val double=multiply(2, _:Int) // 5 
26. double: (Int) => Int 
28. scala> count foreach {i => double(i)}
30. scala> val double2:Int=>Int = multiply(2,_)
31. double2: (Int) => Int = & function>
34. scala> count foreach {i => double2(i)}
36. scala> count reduceLeft {_+_} // 6
37. res3: Int = 55
39. class Generic[T](val t:T)
41. val generic:Generic[_] = new Generic(2) // 7

While at a glance the underscores do not seem related, in fact the general rule is fill in the blank. Sca_la what goes in the blank?

Going through the examples:

1. import anything/everything in package
2. this seems to be an exception. Assign File to oblivion. (It is no longer imported)
3. import all methods in object
4. same thing. Import all methods in instance object
5. creat a new method where the first parameter is defined but all others will be defined later. In this case a special syntax is required so the compiler knows that a new method is desired and the missing parameters was not simply a mistake. There is another syntax for defining methods that do not require the _ for currying
6. reduceLeft takes method with 2 parameters. _ + _ creates a function of 2 parameters: the first '_' represents the first parameter and the second '_' represents the second parameter.
7. the '_' represents any value. This syntax is frowned upon since Scala has such a rich type system but can be useful when interoperating with Java. Perhaps a better declaration would be Generic[Any]