title: Typescript multiple inheritance
body: <p>I'm need of multiple inheritance in typescript.
  Logically it is not good to put a lot of functionality to hierarchy.
  I have one base class and number of hierarchy branches.
  But I need somehow to use mixings to put some main logic in separate classes, cuz it is not used in every branch.</p>
  
  <p>UPDATE of code exmple:</p>
  
  <pre><code>function Mixin = function(mixins:any[]){ // mixin decorator
      return function(target){
          mixins.forEach((mixin) =&gt; {
              add every function from mixing to target prototype, 
              if functions with same name does not exists there,
              so we are able to do calls to as example different render() functions   
  
              Will show it in OpenableItem        
          });
      }
  }
  
  function element = function(){
      return function(target){
          target.prototype.element = function(){
              return this.$el;
          }
      }
  }
  --------------------------------------------------------------------------------------
  @element // every item will have this function as Root as Openable
  class BaseItem{
      y() =&gt; number; // we need to get y position of every item
  }
  OpenableMixin{
      render() =&gt; render arrow only
      open(){} =&gt; change arrow position and cause menu to fire change event
      close(){} =&gt; change arrow position and cause menu to fire change event
  }
  class ItemsMixin extends OpenableMixing{// for now if item have childs it must be openable, 
                      // but Responsive has only tasks and must be openable too
      addItem(item: BaseItem) // need to add generics
      removeItem(item: BaseItem)  
  }
  --------------------------------------------------------------------------------------
  @Mixin([ItemsMixin, ActivitiesMixin]) // it can have items and activities
  class OpenableItem extends BaseItem implement ItemsMixin, ActivitiesMixin { // as in typescript docs
      render(){
          // call rendering from BaseItem class
          super.render();
          // call rendering from OpenableMixing
          OpenableMixin.prototype.render.call(this);
          // do some separate rendering for OpenableItem only
          this.$el.append('line');
      }   
  }
  
  @Mixin([ItemsMixin]) // it can have items
  class RootItem extends BaseItem implement ItemsMixin{ // and subitems functionality is only for Root class
      subitems: Array&lt;BaseItem&gt; // need to add generics to be able to put here different item types
  }
  --------------------------------------------------------------------------------------
  @element
  class Menu{
      items: Array&lt;Item&gt;
  }
  
  @element
  class Timeline{
      menu: Menu
      listAllelement() =&gt; {
          console.log(this.element());
          console.log(this.menu.element());
          this.menu.items.forEach((item) =&gt; {
              console.log(item.element());
              if(item.hasChilds()){  // really it must be (item instanceof RootItem || item instanceof OpenableItem)
                  item.items.forEach((subitem) =&gt; { // really we need some recursion here
                      console.log(subitem.element());
                  })
              }
          })
      }
  }
  </code></pre>
  
  <p>In reality it is rare situation when you need to implement multiple inheritance, and it is much rarely when you can have such an issue in javascript. But every item can have different functionality depending on needs.</p>
  
  <p>Just imagine that there can be different items which can have number of mixins. Is it wise to put everything into base ? And what is your approach to this issue ? </p>