E>abstract trait Function1 [-T1, +R] extends java.lang.Object with scala.ScalaObject
E>

class Animal : Object {}
class Banana : Plant {}
class Apple : Plant {}
class Elephant : Animal {}

function foo(f : Plant->Animal)
{
  Animal animal = f(new Banana);
}

function ok(x : Fruit) : Elephant
{
...
   return new Elephant;
}

function bad1(x : Apple) : Animal
{
   ...   
}

function bad2(x : Plant) : Object
{
   ...   
}
...
foo(ok); // т.к. банан - тоже фрукт, ok умеет с ним работать.
         // т.к. слон - тоже животное, foo сможет обработать возвращенное значение
foo(bad1); // bad1 не справится с бананом, она умеет есть только яблоки
foo(bad2); // foo не поймет, что ей вернула функция bad2, 
           // она ожидала животное, а получила непонятный "объект"

val obj = new Obj
val s = "String"
val x = 10
val t = (s, x)

obj.fn(s, x)           // These two expressions
obj.fn(t)              // are equivalent

Function.tupled(&obj.fn)(t)

[Annotation]TheClass[Param]

E>Но вот появление конструкций x += 1 радует

  def +=(x: T): unit = {
        ...
  }

class Stack[+T] { ... }

class Stack[-T] { ... }

object T1 extends Application
{
  import scala.collection.immutable.Stack

  class Payment {}
  class DangerousPayment extends Payment {}

  def addPaymentTo( p: Payment, storage: Stack[Payment] ) {}

  var dangerousPaymentStorage = new Stack[ DangerousPayment ]
  val nextPayment = new DangerousPayment
  addPaymentTo( nextPayment, dangerousPaymentStorage )
}

abstract trait Function1 [-T1, +R] extends java.lang.Object with scala.ScalaObject

VD>Везет тебе. А страступ считает, что свременный С++ появился где-то в 1994-ом.

E>>abstract trait Function1 [-T1, +R] extends java.lang.Object with scala.ScalaObject
E>>

class IOChannel[-T] { ... }

def storeReportTo( report: List[String], receiver: IOChannel[String] ) { ... }

def openOrCreateReportFile(): IOChannel[String ] = { ... }

val report: List[String] = buildReport
val reportFile: IOChannel[String] = openOrCreateReportFile

storeReportTo( report, reportFile )

def findAppropriateTargetChannel(): IOChannel[AnyRef] = { ... }

val report: List[String] = buildReport
val reportChannel = findAppropriateTargetChannel

storeReportTo( report, reportChannel )

// Вот такое использование аргумента x в методе append недопустимо:
abstract class Vector[+a] {
  def append(x: Vector[a]): Vector[a]
    // **** error: illegal variance:
    // ‘a’ occurs in contravariant position.
}

// Должно быть так:
abstract class Vector[+a] {
  def append[b >: a](x: Vector[b]): Vector[b]
}