anchor.diff:  
   /// Handles CLR types with a single constructor taking 1 or more parameter types,
   /// where all parameter types are supported by `rootHandler`.
  -type SingleConstructorTypeContext(rootHandler : ITypeHandler) =
  -    interface ITypeHandler with
  -        member this.GetKnownTypes = upcast []
  +type SingleConstructorTypeHandler(rootHandler : ITypeHandler) =
  +    interface ITypeHandler with
  +        member this.DefinedTypes = upcast []
           member this.GetMapping(targetType) =
               let constructors = targetType.GetConstructors()
               if constructors.Length <> 1 then None else
  
positive.code: 
  /// Handles types implementing IEnumerable<T> that have a constructor taking an IEnumerable<T>,
  /// where T is supported by `rootHandler`.
  type EnumerableTypeContext(rootHandler : ITypeHandler) =
      let translateEnumerable
          (cons : ConstructorInfo) // constructor taking IEnumerable<clrElementType>
          (clrElementType : Type)
  
negative.code:             , fun (v : Value) -> v.GetBoolean() |> translate |> box)
  
  type ITypeHandler =
      /// Get the types explicitly defined by this handler.
      abstract member DefinedTypes : CoreVariableType seq
      /// Get a mapping for `targetType`, if this handler supports it.
      abstract member GetMapping : targetType : Type -> TypeMapping option
  
  type ZeroTypeHandler() =
      interface ITypeHandler with
          member this.DefinedTypes = upcast []
          member this.GetMapping _ = None
  
  type ChainTypeHandler(primary : ITypeHandler, fallback : ITypeHandler) =
      interface ITypeHandler with
          member this.DefinedTypes = Seq.append primary.DefinedTypes fallback.DefinedTypes
          member this.GetMapping(targetType) =
              match primary.GetMapping(targetType) with
              | Some r -> Some r
  