anchor.diff:          | null -> None 
           | _ -> 
               match Value.GetValueInfo bindingFlags (x, ty) with
  -            | UnionCaseValue (_, "Cons", recd) -> Some (unpackCons recd)
  -            | UnionCaseValue (_, "Empty", [| |]) -> None
  +            | UnionCaseValue ("Cons", recd) -> Some (unpackCons recd)
  +            | UnionCaseValue ("Empty", [| |]) -> None
               | _ -> failwith "List value had unexpected ValueInfo"
   
       let structL = wordL (tagKeyword "struct")
  
positive.code:                 countNodes 1
                  wordL (tagPunctuation "[]")
  
          and unionCaseValueL depthLim prec (declaringType: Type option) unionCaseName recd =
              countNodes 1
              let caseName =
                  match declaringType with
                  | None ->
                      wordL (tagMethod unionCaseName)
                  | Some declaringType ->
                      wordL (tagClass declaringType.Name) ^^ sepL (tagPunctuation ".") ^^ wordL (tagMethod unionCaseName)
              match recd with
              | [] -> caseName
              | recd -> (caseName --- recdAtomicTupleL depthLim recd) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
  
negative.code:         | TupleValue of TupleType * (obj * Type)[]
          | FunctionClosureValue of Type 
          | RecordValue of (string * obj * Type)[]
          | UnionCaseValue of string * (string * (obj * Type))[]
          | ExceptionValue of Type * (string * (obj * Type))[]
          | NullValue
          | UnitValue
          | ObjectValue of obj
  
      module Value =
          // Analyze an object to see if it the representation
          // of an F# value.
          let GetValueInfoOfObject (bindingFlags: BindingFlags) (obj: obj) =
  