Question: I know about using `co-` and `contravariance` in the standard library (e.g. collections and trait `Function`) I wonder how `co-` and `contravariance` are used in design of "real world" business applications.

Answer: 
The classic example is functions, taking the Scala interface for a function with a single argument:

```
trait Function1[-T1, +R]

```

Which is contravariant (the `-`) for the argument, and covariant (the `+`) for the return type.

Why?

Imagine you have these classes:

```
class Timelord { ... }
class Doctor extends Timelord { ... }

class Enemy { ... }
class Dalek extends Enemy { ... }

```

If you have a method that takes, as a parameter, a `Doctor => Enemy` function; then it's okay to supply an instance of `TimeLord => Enemy`. It'll still accept instances of `Doctor`.

So `TimeLord => Enemy` is a *subclass* of `Doctor => Enemy` because `TimeLord` is a *superclass* of `Doctor`, it's **contravariant** in that parameter.

Likewise, a function returning a `Dalek` is valid when you need a function returning some `Enemy`, because a `Dalek` is-an `Enemy`

So `Doctor => Dalek` is a *subclass* of `Doctor => Enemy` because `Dalek` is a *subclass* of `Enemy`, it's **covariant** in that parameter.
Essentially anywhere where you want to make use of both [parametric polymorphism](http://en.wikipedia.org/wiki/Parametric_polymorphism) *(generics)* and inheritance, you will probably end up wanting either [declaration site variance](http://en.wikipedia.org/wiki/Covariance_and_contravariance_%28computer_science%29#Declaration-site_variance_annotations) *(`+`/`-`)*, [use site variance](http://en.wikipedia.org/wiki/Covariance_and_contravariance_%28computer_science%29#Use-site_variance_annotations_.28Wildcards.29) *(wildcards)*, or more likely, both.

Polymorphic types are usually fairly high-level abstractions, so while your domain objects may not need variance annotations, it's likely that code that you write to manipulate your domain objects will need to use variance annotations, at least if your domain objects are part of inheritance hierarchies, which seems very frequent.

If you take a look at essentially any library or framework, you'll find frequent use of variance annotations. If you're abstracting your "real world" application correctly, you'll probably be writing lots of libraries to support it, with a small core of critical business logic nicely decoupled from all of the support infrastructure. All that support infrastructure will probably make frequent use of variance annotations, too.