The code below wraps google collections , in a thin java DSL like wrapper

 public class IterableQuery {

   public static  Where from(Iterable originalCollection) {
      return  new Where( Iterables.transform(originalCollection, IterableQuery.SAME()));
   }

   private static  Function SAME() {
      return new Function(){
         public T apply(T arg0) {
            return arg0;
         }
      };
   }

   public static class SelectOrderBy{

      private final Iterable iterable;

      public SelectOrderBy(Iterable iteable) {
         this.iterable = iteable;
      }

      public  SelectOrderBy orderyBy( Comparator sort ){
          Ordering.forComparator(sort).sort((List) iterable);
          return new SelectOrderBy( iterable);
      }

      public   Iterable select(  Function function){
         return Iterables.transform(iterable, function);
      }
      public  Iterable selectEveryThing( ){
         return iterable;
      }
   }

   public static class Where{

      private final Iterable iterable;

      public Where(Iterable iterable) {
         this.iterable = iterable;
      }

      public    SelectOrderBy where(Predicate predicate) {
         return  new SelectOrderBy( Iterables.filter(iterable, predicate));
      }
   }

}

Now collections could be queried like

 Iterable currentlyAssigned =
             IterableQuery.
              from(orders).
              where(placedInLast10Days).
              orderBy(lastName).
              select(orderToNewOrder);

But this is doesnt have to be limited to frameworks, You can take advantage of this mechanism in your day
to day coding .. here are just two examples of the stuff I’ve used this in the past ( examples below are made up equivalents)

Builders :

Lets say you are writing a weekly activity recorder , the traditional ( boring ..) way of creating it would be

  WeeklyActivityRecorder weeklyActivities = new WeeklyActivityRecorder ();
  weeklyActivities .AddActivity( new Activity{Day = DayOfWeek.Monday , Activity = "Lawn Moving" });
  weeklyActivities .AddActivity( new Activity{Day = DayOfWeek.Tuesday , Activity = "Cooking" });

The ” Code as Data ” way would be ..

  WeeklyActivityRecorder weeklyActivities = new WeeklyActivityRecorder () .WithActivities( Monday => "Lawn Moving",Tuesday => "Cooking");

This looks more readable ( and fun ).. and there is very little work involved to actually achieve this

 public static WeeklyActivityRecorder WithActivities(this WeeklyActivityRecorder recorder, params   Expression<Func<DayOfWeek, string>>[] activities)
 {
  foreach( var activity in activities )
  {
     LambdaExpression expression = activity;
     ConstantExpression activity= expression.Body as ConstantExpression;
     DayOfWeek day =  expression.Parameters[0];
     recorder.AddActivity(new Activity {DayOfWeek = day , Activity = activity});
  }
 return recorder ;
}

Here I define a new extension method on WeeklyActivityRecorder which takes varargs lambda expressions
I then parse the lambda expression to create the appropriate activity , pretty straightforward stuff.

The second example is creating a hibernate criteria from expression tree

Once again the *old* way of querying by property would be by passing in the property by string

  protected IList<T> _FindByProperty(string propertyName , object value)
        {
            return _hibernateTemplate.Execute(
                            session => session.CreateCriteria(typeof(T)).
                            Add(Expression.Eq(propertyName, value)).List())
                            .Cast<T>().ToList();
        }

Code is obviously fragile since you have to use strings as property names which cannot be checked at compile time..

So instead of calling that method directly we could call it through a method which accepts an expression instead of string

</pre>
protected IList<T> _FindByProperty<TResult>(Expression<Func<T, TResult>> expression, TResult value)
 {
 return _FindByProperty((expression.Body as MemberExpression).Member.Name, value);
 }
<pre>

The Above method could now be called as

 IList<User> costCenters = _FindByProperty( user=> user.Name, "surya");

Existence of property “Name” is now checked at compiled time ..Although this technique is powerful, it feels
limited when compared to what you can do in LISP dialects.

For example, Windows Live contact Api

let you specify Field and Depth Filtering via the query param Filter , for example a request like

https://livecontacts.services.live.com/users/@L@<lid>/rest/livecontacts&Filter=LiveContacts(Contact(ID,CID),Tag)

Would retrive live contacts contact with id , CID and tag for live contact .

You could make this infinitely recursive to pick and choose fields you want at any graph depth .

Here is the  antlr grammer for doing just that .. Instructions for how to generate code is available on antlr website

grammar Response;

options {output=AST;}
tokens {
   FIELDSHORTCUT;
   STAR;
}
response:  root (',' root)* -> root+ ;
root 	:fieldshortcut|'*'| (nodewithchildren);
nodewithchildren: (ID LPAREN response RPAREN) -> ^(ID response)
	|ID -> ^(ID STAR)
	|ID '()'-> ^(ID) ;
fieldshortcut
	:	'{'ID'}' -> ^(FIELDSHORTCUT ID);	

ID  :   ('a'..'z'|'A'..'Z')+ ;
INT :   '0'..'9'+ ;
LPAREN 	:	'(';
RPAREN 	:	')';

NEWLINE:'\r'? '\n' ;
WS  :   (' '|'\t')+ { $channel=HIDDEN;} ;

jQuery.extend(jQuery.expr[':'], {
	classStartsWith: function(a, i, m){
		var classes = $(a).attr("className").split(" ")
		var found = false;
		for (var i = 0; i < classes.length; i++) {
			if (classes[i].startsWith(m[3])) {
				found = true;
				break;
			}
		}
		return found;
	}
});

The above code plugs in a custom selector for matching all the elements which have class starting with a certain string so

$('input:classStartsWith('highlight')')

a selector like above would select all the input elements with class starting with highlight .
I guess the code is pretty straight forward so I’m not going to go exegetic on the code .

I ended up writing a jquery plugin which reads the form inputs and converts it into an object graph based on the name attribute, so for an form with the following  inputs

<input  name="order.customerName"  />
<input  name="order.orderItem.qty"  />

you could just say

 var order = $('#myform').params2Object();
 test(order.customerName ==='john');
 test(order.orderItem.qty > 0 );

Here is the actual plugin code ..HTH

jQuery.fn.params2Object = function(){
    var d = this.serializeArray()
    var data = {};
    for (var i = 0; i < d.length; i++) {
        var tokens = d[i].name.split('.');
        _setValue(data, tokens, d[i].value);
    }
    return data;

    function _setValue(obj, tokens, value, index){
        if (tokens.length == 1) {
            if (typeof index != 'undefined') {
                obj[index] = obj[index] ||
                {};
                obj[index][tokens[0]] = value;
            }
            else {
                obj[tokens[0]] = value;
            }
        }
        else {
            var prop = _getProperty(tokens[0]);
            obj[prop.name] = obj[prop.name] || (prop.isArray ? [] : {});
            _setValue(obj[prop.name], tokens.slice(1, tokens.length), value, prop.index);
        }
    }

    function _getProperty(token){
        var arraySplit = token.split('[');
        if (arraySplit.length > 1) {
            var propName = arraySplit[0];
            var index = arraySplit[1].split(']')[0];
        }
        else {
            var propName = token;
        }
        return {
            name: propName,
            index: index,
            isArray: token.indexOf(']') > 0
        };

    }

};

I happened to catch up on my “mainstream” listening this week .. so I picked 3 albums and all three of them had *traditional* indian instruments in them..

• Sitar , Yes – Viva La Vida , Coldplay ( http://www.imeem.com/dazhini/music/3IS9giaS/coldplay_yes_chinese_sleep_chant/
• Tabla , Citizen of the Planet – Flavors of entanglement Alanis Morissette
  ( http://www.youtube.com/watch?v=TmnLBPENNys)
• Tabla Again , Pity And Fear – Narrow Stairs , Death Cab For Cutie ( http://www.youtube.com/watch?v=pyyaSbSC61MAhh..Now I get what they meant when they said this is their *Experimental* Album
• Sitar , Loser – Mellow Gold , Beck ( http://www.youtube.com/watch?v=TJN3PGqDRNg )

Or .. I guess it was just a coincidence that the three ablums I picked up happened to have indian instruments in them ..

Either way its cool .. my brain subconsciously puts a seal of approval on a song which has even a minor smattering of sitar , tabla , flute or any other awesome instruments ..

Bonus : *Teen Mar* in British Accent ( http://www.youtube.com/watch?v=fZv-G7IISgs)

Round 1.0 – GENERICS

1. No Type Erasure in C # , new T() anyone ??
2. Value types like int or Enumeration can be be used as type parameter so MyClass<int> is perfectly valid.
3. No Wildcards in C# which I terribly miss , Cast<>() from Linq Enumerable doesnt look too pretty
4. Java has better support for covariant and contravariant for type parameters , I dearly miss ” ? ” from java.
5. Assignment Type inference works in Java but not C#
   in Java,
   public T <T> myMethod()
   T var = myMethod() ; // T is inferred here !!!
   in C#
   public T MyMethod<T>()
   T var = myMethod() ; // T cannot be inferred from the assignment here!!!

This round clearly goes to C# …Generics done right ( almost ..)

Round 2.0 Enums

Java has enum support too..but whats different with enums in C# is

But that forces us to create several meaningless little classes just for the sake of mapping and if its always the string name of the enum why go through all that ?

Option 2 : Create a Generic Enum mapping usertype ..which might look like …

public class EnumMappingType : IEnhancedUserType , IParameterizedType
    {
        private Type enumClass;

        public  string Name
        {
            get { return "enumstring - " + enumClass.Name; }
        }

        public  Type ReturnedClass
        {
            get { return enumClass; }
        }
        public object StringToObject(string xml)
        {
            return null;
        }

        public object FromXMLString(string xml)
        {
            throw new NotImplementedException();
        }

        public string ObjectToSQLString(object value)
        {
            return GetValue(value).ToString();
        }
        public virtual object GetValue(object code)
        {
            //code is an enum instance.
            return code == null ? string.Empty : code.ToString();
        }

        public void SetParameterValues(IDictionary parameters)
        {
           enumClass = Type.GetType((string) parameters["enumClass"],true);
        }

        public  object FromStringValue(string xml)
        {
            return GetInstance(xml);
        }
        public virtual object GetInstance(object code)
        {
            //code is an named constants defined for the enumeration.
            try
            {
                return Enum.Parse(enumClass, code as string, true);
            }
            catch (ArgumentException ae)
            {
                throw new HibernateException(string.Format("Can't Parse {0} as {1}", code, enumClass.Name), ae);
            }
        }

        public  string ToString(object value)
        {
            return (value == null) ? null : GetValue(value).ToString();
        }

        public  bool Equals(object x, object y)
        {
            return (x == y) || (x != null && y != null && x.Equals(y));
        }

        public int GetHashCode(object x)
        {
            throw new NotImplementedException();
        }

        public object NullSafeGet(IDataReader rs, string[] names, object owner)
        {
            object code = rs[rs.GetOrdinal(names[0])];
            if (code == DBNull.Value || code == null)
            {
                return null;
            }
            return GetInstance(code);
        }

        public void NullSafeSet(IDbCommand cmd, object value, int index)
        {
            IDataParameter par = (IDataParameter)cmd.Parameters[index];
            if (value == null)
            {
                par.Value = DBNull.Value;
            }
            else
            {
                par.Value = Enum.Format(this.enumClass, value, "G");
            }
        }

        public object DeepCopy(object value)
        {
            return value;
        }

        public object Replace(object original, object target, object owner)
        {
            return original;
        }

        public object Assemble(object cached, object owner)
        {
            return cached;
        }

        public object Disassemble(object value)
        {
            return value;
        }

        public SqlType[] SqlTypes
        {
            get { return new[] { SqlTypeFactory.GetString(10) }; }
        }

        public Type ReturnedType
        {
            get { return enumClass; }
        }

        public bool IsMutable
        {
            get {return false; }
        }
    }
 

And the corresponding mapping file can be ( you can also create shortcut typedef’s btw )

<property  name="EnumPropertyName">
      <column name="EnumPropertyName" sql-type="nvarchar(50)" not-null="true"/>
      <type name ="....EnumMappingType, Assembly.Name">
        <param name ="enumClass">Your.Enum.ClassName</param>
      </type>
</property>

Hope that helps someone out there !!!

This is a windows only release , I still have to iron out few kinks for the Mac version .

You can choose the providers which get queried and can edit ( or paste your own) lyrics before applying them to a track.

The UI is primitive ( but usable ) , on which I plan to work after I get the mac version working.