anchor.diff:            let rowReader = unbox<IVector<obj>> o
             ObjectSeries(columnIndex, rowReader, vectorBuilder, indexBuilder) )
   
  -    // `RowSeriesFromFrame` delegates slicing to the frame by calling 
  +    // The following delegates slicing to the frame by calling 
       // `frame.GetSubrange` which is more efficient than re-creating from rows
  -    RowSeries<_, _>.FromFrame(rowIndex, vector, frame)
  +    //
  +    // NOTE: Why do we use `RowSeries<_, _>.FromSeries` above and inline object
  +    // expression here? Due to some odd type inference in recursive type definitions,
  +    // this is the only way to make it work... :-/
  +    { new RowSeries<'TRowKey, 'TColumnKey>(rowIndex, vector, frame.VectorBuilder, frame.IndexBuilder) with
  +        override x.GetSlice(lo, hi) = 
  +          let inclusive v = v |> Option.map (fun v -> v, BoundaryBehavior.Inclusive)
  +          frame.GetSubrange(inclusive lo, inclusive hi) }
   
     /// [category:Accessors and slicing]
     member frame.Item 
  
positive.code:     RowSeries<_, _>.FromSeries(Series.dropMissing res) 
  
    /// [category:Accessors and slicing]
    member frame.Rows =    
      // This operation needs to work on virtualized frames (by returning a
      // virtualized series) and it also needs to be efficient for in-memory frames.
      // We do this by creating `Combine([...], NaryTransform.RowReader)` command - 
  
negative.code:     ColumnSeries(Series(columnIndex, newData, vectorBuilder, indexBuilder))
  
    /// [category:Accessors and slicing]
    member frame.RowsDense : RowSeries<'TRowKey, 'TColumnKey> = 
      // Create an in-memory series that contains `ObjectSeries` for each
      // row that has a value for each column. This returns an in-memory
      // series because we do not know how many rows we'll need to return.
  