anchor.diff:  /// Information needed to represent a field in FlexSearch document
   /// This should only contain information which is fixed for a given type so that the
   /// instance could be cachced. Any Index specific information shouls go to FieldSchema
  -[<Interface>]
  -type IField = 
  -    
  -    
  +[<AbstractClass>]
  +type FieldBase() = 
       abstract Suffix : string option
  -    abstract SubTypes : IField [] option
  +    abstract SubTypes : FieldBase [] option
       abstract FieldType : FlexSearch.Api.Constants.FieldType
       abstract LuceneFieldType : LuceneFieldType
  -    abstract SortFieldType : SortFieldType option
  +    abstract SortFieldType : SortFieldType
       abstract DefaultStringValue : string
  -    abstract ToInternal : string -> BasicDataType
  +    abstract DefaultBasicValue : BasicDataType
  +    abstract ToInternal : fieldName:string -> fieldValue:string -> BasicDataType
       abstract ToExternal : fieldName:string -> fieldValue:string -> string
  -    abstract Validate : fieldName:string -> fieldValue:string -> BasicDataType option
  -    abstract DefaultValue : BasicDataType
       abstract CreateFieldTemplate : schemaName:string -> generateDocValue:bool -> FieldTemplate
       abstract UpdateFieldTemplate : fieldName:string -> document:Dictionary<string, string> -> FieldTemplate -> unit
  +
  +[<AbstractClass>]
  +type BasicFieldBase<'T>(fieldType, luceneFieldType, sortFieldType, defaultValueString) = 
  +    inherit FieldBase()
  +    abstract DefaultValue : 'T
  +    override __.Suffix = None
  +    override __.SubTypes = None
  +    override __.FieldType = fieldType
  +    override __.LuceneFieldType = luceneFieldType
  +    override __.DefaultStringValue = defaultValueString
  +    override __.SortFieldType = SortFieldType.SCORE
  +    override __.ToExternal (fieldName : string) (value : string) = value
  +    abstract Validate : fieldName:string -> fieldValue:string -> 'T
   
   /// Represents a field in an Index.
   type FieldSchema = 
  
positive.code:     member this.TryGetValue(key : string) = this.Dictionary.TryGetValue(key)
      member this.ReadOnlyDictionary = new ReadOnlyDictionary<string, FieldSchema>(this.Dictionary)
  
  module LuceneFieldHelpers = 
      /// A field that is indexed but not tokenized: the entire String value is indexed as a single token. 
      /// For example this might be used for a 'country' field or an 'id' field, or any field that you 
      /// intend to use for sorting or access through the field cache.
      let getStringField (fieldName, value : string, store : FieldStore) = 
          new StringField(fieldName, value, store) :> LuceneField
      
      /// A field that is indexed and tokenized, without term vectors. For example this would be used on a 
      /// 'body' field, that contains the bulk of a document's text.
      let getTextField (fieldName, value, store) = new TextField(fieldName, value, store) :> LuceneField
      
      let getLongField (fieldName, value : int64, store : FieldStore) = 
          new LongField(fieldName, value, store) :> LuceneField
      let getIntField (fieldName, value : int32, store : FieldStore) = 
          new IntField(fieldName, value, store) :> LuceneField
      let getDoubleField (fieldName, value : float, store : FieldStore) = 
          new DoubleField(fieldName, value, store) :> LuceneField
      let getFloatField (fieldName, value : float32, store : FieldStore) = 
          new FloatField(fieldName, value, store) :> LuceneField
      let getStoredField (fieldName, value : string) = new StoredField(fieldName, value) :> LuceneField
      let getBinaryField (fieldName) = new StoredField(fieldName, [||]) :> LuceneField
      let getField (fieldName, value : string, template : FlexLucene.Document.FieldType) = 
          new LuceneField(fieldName, value, template)
      let bytesForNullString = System.Text.Encoding.Unicode.GetBytes(Constants.StringDefaultValue)
  
  
negative.code:     
      /// Returns the Sort field associated with the field
      let sortField (schema : FieldSchema) = schema.Field.SortFieldType
      
      /// Signifies if a field is represented using multiple fields in the index
      let hasSubType (field : FieldBase) = field.SubTypes.IsSome
  
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module TypeIndentity = 
  