anchor.diff:  So, when writing a rule using a trait interface, only the fields of the interface will be available, as usual.
   However, any field in the interface that corresponds to a core object field, will be mapped by the proxy class:
   
  -====
   [source]
   ----
   when
  
positive.code:     $sc.setDiscount( ... ); // soft setter
  end
  ----
  ====
  
  
  A core object also holds a reference to all its proxies, so that it is possible to track which type(s) have been added to an object, using a sort of dynamic "instanceof" operator, which we called isA.
  The operator can accept a String, a class literal or a list of class literals.
  In the latter case, the constraint is satisfied only if all the traits have been donned. 
  
  ====
  [source]
  ----
  $sc : GoldenCustomer( $maxExpense : maxExpense > 1000,
                        this isA "SeniorCustomer", this isA [ NationalCustomer.class, OnlineCustomer.class ]
  )
  ----
  ====
  
  
  Eventually, the business logic may require that a trait is removed from a wrapped object.
  To this end, we provide two options.
  The first is a "logical don", which will result in a logical insertion of the proxy resulting from the traiting operation.
  The TMS will ensure that the trait is removed when its logical support is removed in the first place.
  
  ====
  ++++
  <programlisting>then
      <emphasis role="bold">don</emphasis>( $x, // core object
           Customer.class, // trait class
           true // optional flag for logical insertion
      )</programlisting>
  ++++
  ====
  
  
  The second is the use of the "shed" keyword, which causes the removal of any type that is a subtype (or equivalent) of the one passed as an argument.
  Notice that, as of version 5.5, shed would only allow to remove a single specific trait.
  
  ====
  ++++
  <programlisting>then
      Thing t = <emphasis role="bold">shed</emphasis>( $x, GoldenCustomer.class ) // also removes any trait that</programlisting>
  ++++
  ====
  
  
  This operation returns another proxy implementing the org.drools.core.factmodel.traits.Thing interface, where the getFields() and getCore() methods are defined.
  
negative.code: In fact, any object can don a trait, provided that they are declared as @Traitable.
  Notice that this annotation used to be optional, but now is mandatory.
  
  [source]
  ----
  import org.drools.core.factmodel.traits.Traitable;
  declare Customer
      @Traitable
      code    : String
      balance : long
  end
  ----
  
  
  The only connection between core classes and trait interfaces is at the proxy level: a trait is not specifically tied to a core class.
  