anchor.diff:              ??> new BuiltinTypeHandler()
               ??> new NullableTypeHandler(root)
               ??> new ArrayTypeHandler(root)
  +            ??> new SequenceInterfaceTypeHandler(root)
               ??> new CollectionTypeHandler(root)
  -            ??> new EnumerableTypeHandler(root)
  +            ??> new EnumerableConstructorTypeHandler(root)
               ??> new SingleConstructorTypeHandler(root)
           )
       let enumValuesByName = new Dictionary<string, EnumValue>()
  
positive.code: open System.Reflection
  open System.Collections.Generic
  
  type TypeMapping(clrType : Type, varType : VariableType, translate : Value -> obj) =
      member this.CLRType = clrType
      member this.VariableType = varType
      member this.Translate = translate
  
  type ITypeHandler =
  
negative.code:             let parameters = cons.GetParameters()
              if parameters.Length < 1 then None else
              let fields =
                  lazy (
                      [
                          for parameter in parameters do
                              let varTy = rootHandler.VariableTypeOf(parameter.ParameterType)
                              yield parameter.Name, varTy
                      ] |> dictionary)
              let varType = lazy (ObjectType fields.Value).Nullable(not targetType.IsValueType)
              new TypeMapping
                  ( targetType
                  , varType
                  ,
                      function
                      | NullValue -> null
  