Is there a generic constraint I could use for the + operator?

There are no such devices in C#. A few options are available, though:

• in C# 4.0 and .NET 4.0 (or above), use dynamic, which supports + but offers no compile time checking
• in .NET 3.5 (or above), MiscUtil offers an Operator class which makes operators available as methods - again, without any compile-time checking

So either:

return (dynamic)left.Evaluate(context) + (dynamic)right.Evaluate(context);

or

return Operator.Add(left.Evaluate(context), right.Evaluate(context));

The Type parameter constraints in C# are very limited and is listed here. So the answer is no as far as compile time check goes. If T is a type that you create and manage, one way to go about it would be to

interface IAddable 
{
   IAddable Add(IAddable foo);
}

and implement IFoo for all your types and use where T: IAddable as constraint and use Add() instead of +

Using a generic constraints you can force T

• to be a reference type or a value type
• to inherit from a certain class
• to implement certain interface
• to have parameterless constructor

But that's all. You can't force the existence of the static operator+ on it.