Compiler should allow the following syntax:

```
struct Base
{
  int foo;
}

struct Derived mixin Base
{
    int mult(int bar)
    {
        return foo * bar;
    }
}

void main()
{
  auto d = Derived(10);
  d.mult(2);
}
```

The syntax allows to mixin any other struct, template mixin or interface in the body of the type that is declared. Syntax should allow mixin in parameterized types also, i.e.
 
`struct Foo(T) mixin Bar!T`

The use case for this is to simplify creation of POD types that use common functionality, akin to inheritance - but not polymorphic.

Another useful feature will be the possibility to implement interface contracts non-polymorphically, for example:

```
interface Animal
{
  void talk();
  
  final void terminate()
  {
    // implementation provided
  }
}

struct Derived mixin Animal
{
    void talk()
    {
        // implement
    }
}

void main()
{
  Derived d;
  d.talk();
  d.terminate();
}
```

The compiler will emit an error for methods not implemented from mixin interfaces

The usage of the `mixin` keyword instead of the `:` symbol for existing class inheritance signals that the two are not equivalent, and it also builds on the existing semantics of the mixin concept.