lang.scala (date)

["Judson, Ross" <rjudson@xxxxxxxxxxxxxxxxxx>]

Scala performs type inferencing -- making use of context to attempt a
determination of type.  Does doing the same thing with traits make
sense?  That is, if we define a trait to have a "signature" of some sort
(the set of abstract methods), could the compiler automatically
construct a view?  Given:

trait BuySellProperty {
  def buyProperty(address: String): boolean;
  def sellProperty(address: String): boolean;
}


class Agent {
  def buyProperty(address: String): boolean = {
    Console.println("Buy"); true 
  }
  def sellProperty(address: String): boolean = {
    Console.println("Sell"); true 
  }
}

def usage[A %> BuySellProperty](bs: A) = bs.buyProperty("somewhere");

The compiler would automatically construct:

def view(agent: Agent): BuySellProperty;

The compiler can implement by building a flyweight object, or by
modifying the runtime rep of Agent have a "with" clause.  

This goes to the "duck typing" issue.  I'm not entirely sure about
whether that is advisable or not.  Scala's FunctionN[T...] notation
already performs this sort of thing.  Trait inferencing opens this
mechanism up past functions to include more sophisticated protocols.
The essential "win" (and maybe it isn't one!) here is that a given class
need not formally commit to its set of types.  The compiler can
determine if a class could be a member of a type, make that happen
automatically.  

RJ