anchor.diff:              | :? System.NotSupportedException -> true) //for dynamic assemblies, just assume idiomatic generic value
   
   //suprisingly, this is actually used twice.
  -///test whether the Expr is a Var and equals the given Var property-wise
  +///Test whether the Expr is a Var and equals the given Var property-wise
   let varEqualsExpr (x:Var) = function
       | Var y -> x.Name = y.Name && x.Type = y.Type && x.IsMutable = y.IsMutable
       | _ -> false
   
  +///Test whether the given expression represents a tuple let binding: e.g. let x,y = 1,2.
  +///Must come before Let pattern and after IncompleteLambdaCall pattern.
   let (|TupleLet|_|) x =
       ///TupleLet start variation 1) let a = TupleGet(tupleProperty, index) in let b = TupleGet(tupleProperty, index) in ...
       let (|TupleLetStart1|_|) = function
  
positive.code: let isListUnionCase (uci:UnionCaseInfo) = 
      uci.DeclaringType.IsGenericType && uci.DeclaringType.GetGenericTypeDefinition() = typedefof<list<_>>
  
  let isGenericValue =
      memoize //performance testing shows about 10% performance increase in SourceOpTests.``Call distinguishes between generic value Call and unit function Call`` using memoization 
          (fun (mi:MemberInfo) ->
  
negative.code:     | _ -> None
  
  ////need to check all args are reduced?
  ///Partial application and zero application of Lambda call (e.g. List.map (+), or id).
  ///Must come before Let and Lambdas patterns.
  ///Cases: 1) Let .. Lambdas .. Call
  ///       2) Lambdas .. Call
  let (|IncompleteLambdaCall|_|) x =
      match x with
  